public void Assign()
{
var data = DummyFilteredPassData();
var data2 = new FilteredPassData();
data.Assign(data2);
data2.Should().BeEquivalentTo(data2);
}
public void Clear()
{
var data = DummyFilteredPassData();
var data2 = new FilteredPassData();
data.Clear();
data2.Clear();
data.Should().BeEquivalentTo(data2);
}
public void Test_HeightClientLeafSubGridTests_AssignableFilteredValueIsNull_False()
{
var clientGrid = ClientLeafSubGridFactoryFactory.CreateClientSubGridFactory().GetSubGrid(GridDataType.Height) as ClientHeightLeafSubGrid;
var passData = new FilteredPassData {
FilteredPass = new CellPass {
Height = 42.0f
}
};
Assert.False(clientGrid.AssignableFilteredValueIsNull(ref passData), "Filtered value stated as null when it is not");
}
public void AddOneCellPass_FilteredCellPass()
{
var info = new FilteredMultiplePassInfo();
var filteredPassData = new FilteredPassData
{
FilteredPass = ATestCellPass()
};
info.AddPass(filteredPassData);
info.PassCount.Should().Be(1);
info.FilteredPassData.Should().NotBeNull();
}
public void CreationWithPasses()
{
var pass = ATestCellPass();
var filteredPassData = new FilteredPassData();
filteredPassData.FilteredPass = pass;
var info = new FilteredMultiplePassInfo(new [] { filteredPassData });
info.PassCount.Should().Be(1);
info.FilteredPassData.Should().NotBeNull();
info.FilteredPassData[0].Should().BeEquivalentTo(filteredPassData);
}
public void FromToBinary()
{
var data = DummyFilteredPassData();
var writer = new TestBinaryWriter();
data.ToBinary(writer);
var data2 = new FilteredPassData();
data2.FromBinary(new TestBinaryReader(writer._stream.BaseStream as MemoryStream));
data2.Should().BeEquivalentTo(data2);
}
public void AssignableFilteredValueIsNull()
{
var clientGrid = TestSubGrid();
var passData = new FilteredPassData
{
FilteredPass = new CellPass
{
Height = CellPassConsts.NullHeight
}
};
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeTrue();
passData.FilteredPass.Height = 10.0f;
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeFalse();
}
public void AssignableFilteredValueIsNull()
{
var clientGrid = ClientLeafSubGridFactoryFactory.CreateClientSubGridFactory().GetSubGrid(GridDataType.MachineSpeed) as ClientMachineSpeedLeafSubGrid;
var passData = new FilteredPassData
{
FilteredPass = new CellPass
{
MachineSpeed = CellPassConsts.NullMachineSpeed
}
};
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeTrue();
passData.FilteredPass.MachineSpeed = 100;
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeFalse();
}
public void AssignableFilteredValueIsNull()
{
var clientGrid = ClientLeafSubGridFactoryFactory.CreateClientSubGridFactory().GetSubGrid(GridDataType.Temperature) as ClientTemperatureLeafSubGrid;
var passData = new FilteredPassData
{
FilteredPass = new CellPass
{
MaterialTemperature = CellPassConsts.NullMaterialTemperatureValue
}
};
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeTrue();
passData.FilteredPass.MaterialTemperature = 100;
clientGrid.AssignableFilteredValueIsNull(ref passData).Should().BeFalse();
}
/*
* /// <summary>
* /// Constructor. Set the grid to CellProfile.
* /// </summary>
* /// <param name="owner"></param>
* /// <param name="parent"></param>
* /// <param name="level"></param>
* /// <param name="cellSize"></param>
* /// <param name="indexOriginOffset"></param>
* public ClientCellProfileLeafSubGrid(ISubGridTree owner, ISubGrid parent, byte level, double cellSize, uint indexOriginOffset) : base(owner, parent, level, cellSize, indexOriginOffset)
* {
* Initialise();
* }
*/
public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue)
{
switch (ProfileDisplayMode)
{
case DisplayMode.CCVPercent:
case DisplayMode.CCVSummary:
case DisplayMode.CCVPercentSummary:
case DisplayMode.CCVPercentChange:
return(filteredValue.FilteredPass.CCV == CellPassConsts.NullCCV);
case DisplayMode.MDPPercent:
case DisplayMode.MDPSummary:
case DisplayMode.MDPPercentSummary:
return(filteredValue.FilteredPass.MDP == CellPassConsts.NullMDP);
default:
return(filteredValue.FilteredPass.Time == Consts.MIN_DATETIME_AS_UTC);
}
}
/// <summary>
/// Assigns the cell passes contained in a set of filtered pass values into this layer
/// </summary>
public void Assign(FilteredMultiplePassInfo cellPassValues)
{
Clear();
if (Owner.Layers.Count() != 0)
{
throw new TRexSubGridProcessingException("Cannot assign layers if there are already layers in the cell");
}
if (cellPassValues.PassCount > 0)
{
var filteredPasses = new FilteredPassData[cellPassValues.PassCount];
Array.Copy(cellPassValues.FilteredPassData, filteredPasses, cellPassValues.PassCount);
Owner.SetFilteredPasses(filteredPasses);
StartCellPassIdx = 0;
EndCellPassIdx = cellPassValues.PassCount - 1;
CellPass LastPass = Owner.Passes.FilteredPassData[EndCellPassIdx].FilteredPass;
CellTargets TargetValues = Owner.Passes.FilteredPassData[EndCellPassIdx].TargetValues;
Height = LastPass.Height;
LastLayerPassTime = LastPass.Time;
CCV = LastPass.CCV;
MDP = LastPass.MDP;
CCA = LastPass.CCA;
TargetCCV = TargetValues.TargetCCV;
TargetMDP = TargetValues.TargetMDP;
TargetCCA = TargetValues.TargetCCA;
RadioLatency = LastPass.RadioLatency;
Frequency = LastPass.Frequency;
RMV = LastPass.RMV;
Amplitude = LastPass.Amplitude;
MaterialTemperature = LastPass.MaterialTemperature;
}
}
public void Creation()
{
var data = new FilteredPassData();
data.MachineType.Should().Be(MachineType.Unknown);
}
public static void PopulateFilteredValues(IProductionEventLists values,
IFilteredValuePopulationControl PopulationControl,
ref FilteredPassData filteredPass)
{
// todo bool UseMachineRMVThreshold;
// todo short OverrideRMVJumpThreshold;
if (values == null)
{
Log.LogError($"MachineTargetValues supplied to PopulateFilteredValues is null. PopulationControl = {PopulationControl.GetFlags():X}");
return;
}
DateTime _Time = filteredPass.FilteredPass.Time;
if (PopulationControl.WantsTargetCCVValues)
{
filteredPass.TargetValues.TargetCCV = values.TargetCCVStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullCCV);
}
if (PopulationControl.WantsTargetMDPValues)
{
filteredPass.TargetValues.TargetMDP = values.TargetMDPStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullMDP);
}
if (PopulationControl.WantsTargetCCAValues)
{
filteredPass.TargetValues.TargetCCA = values.TargetCCAStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullCCATarget);
}
if (PopulationControl.WantsTargetPassCountValues)
{
filteredPass.TargetValues.TargetPassCount = values.TargetPassCountStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullPassCountValue);
}
if (PopulationControl.WantsTargetLiftThicknessValues)
{
filteredPass.TargetValues.TargetLiftThickness = values.TargetLiftThicknessStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullOverridingTargetLiftThicknessValue);
}
// Design Name...
if (PopulationControl.WantsEventDesignNameValues)
{
filteredPass.EventValues.EventDesignNameID = values.MachineDesignNameIDStateEvents.GetValueAtDate(_Time, out _, Common.Consts.kNoDesignNameID);
}
// Vibration State...
if (PopulationControl.WantsEventVibrationStateValues)
{
filteredPass.EventValues.EventVibrationState = values.VibrationStateEvents.GetValueAtDate(_Time, out _, VibrationState.Invalid);
if (filteredPass.EventValues.EventVibrationState != VibrationState.On)
{
filteredPass.FilteredPass.SetFieldsForVibeStateOff();
}
}
// Auto Vibration State...
if (PopulationControl.WantsEventAutoVibrationStateValues)
{
filteredPass.EventValues.EventAutoVibrationState =
values.AutoVibrationStateEvents.GetValueAtDate(_Time, out _, AutoVibrationState.Unknown);
}
// IC Flags...
if (PopulationControl.WantsEventICFlagsValues)
{
filteredPass.EventValues.EventFlags = values.ICFlagsStateEvents.GetValueAtDate(_Time, out _, 0);
}
// Machine Gear...
if (PopulationControl.WantsEventMachineGearValues)
{
filteredPass.EventValues.EventMachineGear = values.MachineGearStateEvents.GetValueAtDate(_Time, out _, MachineGear.Null);
}
// RMV Jump Threshold...
if (PopulationControl.WantsEventMachineCompactionRMVJumpThreshold)
{
filteredPass.EventValues.EventMachineRMVThreshold = values.RMVJumpThresholdEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullRMV);
// TODO: PopulationControl.WantsEventMachineCompactionRMVJumpThreshold does not honour global RMV override values
/*
* if TICSiteModel(Owner).GetMachineRMVOverrideState(filteredPass.FilteredPass.InternalSiteModelMachineIndex,
* UseMachineRMVThreshold, OverrideRMVJumpThreshold))
* {
* if (UseMachineRMVThreshold)
* filteredPass.EventValues.EventMachineRMVThreshold = values.RMVJumpThresholdEvents.GetValueAtDate(_Time, out _);
* else
* filteredPass.EventValues.EventMachineRMVThreshold = OverrideRMVJumpThreshold;
* }
*/
}
// Machine Automatic States...
if (PopulationControl.WantsEventMachineAutomaticsValues)
{
filteredPass.EventValues.EventMachineAutomatics =
values.MachineAutomaticsStateEvents.GetValueAtDate(_Time, out _, AutomaticsType.Unknown);
}
if (PopulationControl.WantsEventMapResetValues)
{
throw new NotImplementedException("PopulationControl.WantsEventMapResetValues not implemented");
/*
* filteredPass.EventValues.MapReset_DesignNameID = values.?????.GetValueAtDate(_Time, out int _);
* // LocateClosestPreviousMapResetAtDate(MachineTargetValues, _Time, MapReset_PriorDate, MapReset_DesignNameID);
*/
}
if (PopulationControl.WantsEventElevationMappingModeValues)
{
filteredPass.EventValues.EventElevationMappingMode =
values.ElevationMappingModeStateEvents.GetValueAtDate(_Time, out _, ElevationMappingMode.LatestElevation);
}
if (PopulationControl.WantsEventInAvoidZoneStateValues)
{
throw new NotImplementedException("PopulationControl.WantsEventInAvoidZoneStateValues not implemented");
}
if (PopulationControl.WantsEventGPSAccuracyValues)
{
GPSAccuracyAndTolerance value = values.GPSAccuracyAndToleranceStateEvents.GetValueAtDate(_Time, out _, NullGPSAccuracyAndTolerance);
filteredPass.EventValues.GPSAccuracy = value.GPSAccuracy;
filteredPass.EventValues.GPSTolerance = value.GPSTolerance;
}
if (PopulationControl.WantsEventPositioningTechValues)
{
filteredPass.EventValues.PositioningTechnology = values.PositioningTechStateEvents.GetValueAtDate(_Time, out _, PositioningTech.Unknown);
}
if (PopulationControl.WantsTempWarningLevelMinValues)
{
filteredPass.TargetValues.TempWarningLevelMin = values.TargetMinMaterialTemperature.GetValueAtDate(_Time, out _, CellPassConsts.NullMaterialTemperatureValue);
filteredPass.TargetValues.TempWarningLevelMax = values.TargetMaxMaterialTemperature.GetValueAtDate(_Time, out _, CellPassConsts.NullMaterialTemperatureValue);
}
if (PopulationControl.WantsLayerIDValues)
{
filteredPass.EventValues.LayerID = values.LayerIDStateEvents.GetValueAtDate(_Time, out _, CellPassConsts.NullLayerID);
}
}
/*
* /// <summary>
* /// Constructor. Set the grid to CellProfile.
* /// </summary>
* /// <param name="owner"></param>
* /// <param name="parent"></param>
* /// <param name="level"></param>
* /// <param name="cellSize"></param>
* /// <param name="indexOriginOffset"></param>
* public ClientCellProfileAllPassesLeafSubgrid(ISubGridTree owner, ISubGrid parent, byte level, double cellSize, uint indexOriginOffset) : base(owner, parent, level, cellSize, indexOriginOffset)
* {
* Initialise();
* }
*/
public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) => filteredValue.FilteredPass.Time == Consts.MIN_DATETIME_AS_UTC;
/// <summary>
/// Special version of ProcessCellPasses when using a pass count range Filter.
/// Performs primary filtered iteration over cell passes in the cell being processed to determine the cell pass
/// to be selected.
/// </summary>
private void ProcessCellPassesPassCountRange()
{
_haveFilteredPass = false;
var haveHalfPass = false;
var passRangeCount = 0;
int idxPtr;
var arrayLength = 1000;
var filteredPassDataArray = new FilteredPassData[arrayLength];
var filteredPassBoolArray = new bool[arrayLength];
var passes = 0;
var validPasses = 0;
var minElevCheckRequired = false;
_firstPassMinElev = false;
while (_cellPassIterator.MayHaveMoreFilterableCellPasses() &&
_cellPassIterator.GetNextCellPass(ref _currentPass.FilteredPass))
{
FiltersValuePopulation.PopulateFilteredValues(_siteModel.MachinesTargetValues[_currentPass.FilteredPass.InternalSiteModelMachineIndex], _populationControl, ref _currentPass);
if (_filter.AttributeFilter.FilterPass(ref _currentPass, _filterAnnex))
{
if (_gridDataType == GridDataType.Temperature)
{
// make sure we have a valid temperature pass
var materialTemperature = _currentPass.FilteredPass.MaterialTemperature;
if (materialTemperature != CellPassConsts.NullMaterialTemperatureValue)
{
if (_filter.AttributeFilter.HasTemperatureRangeFilter)
{
if (Range.InRange(materialTemperature, _filter.AttributeFilter.MaterialTemperatureMin, _filter.AttributeFilter.MaterialTemperatureMax))
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
}
}
// Add valid pass to list for pass count range filter
if (_haveFilteredPass)
{
filteredPassDataArray[passes] = _currentPass;
passes++;
if (passes == arrayLength - 1)
{
arrayLength = arrayLength + 500;
Array.Resize(ref filteredPassDataArray, arrayLength);
Array.Resize(ref filteredPassBoolArray, arrayLength);
}
_haveFilteredPass = false; // reset
}
} // end while more passes
_haveFilteredPass = false; // reset for next test
// For pass count range filtering we must walk from earliest to latest
// setup idxPtr to walk forward in time
if (_cellPassIterator.SegmentIterator.IterationDirection == IterationDirection.Forwards)
{
idxPtr = 0;
}
else
{
idxPtr = passes - 1; // last entry is earliest
}
if (passes > 0)
{
for (var i = 0; i < passes; i++)
{
if (i > 0)
{
if (_cellPassIterator.SegmentIterator.IterationDirection == IterationDirection.Forwards)
{
idxPtr++;
}
else
{
idxPtr--;
}
}
_currentPass = filteredPassDataArray[idxPtr];
if (_currentPass.FilteredPass.HalfPass)
{
if (haveHalfPass)
{
passRangeCount++; // increase count on second half pass encountered
}
else
{
haveHalfPass = true;
continue; // wont be using first half pass
}
haveHalfPass = false;
}
else
{
passRangeCount++; // increase count for a full pass
}
if (Range.InRange(passRangeCount, _filter.AttributeFilter.PassCountRangeMin, _filter.AttributeFilter.PassCountRangeMax))
{
filteredPassBoolArray[idxPtr] = true; // tagged for minElev check
if (_filter.AttributeFilter.HasElevationTypeFilter)
{
_assignmentContext.FilteredValue.PassCount = 1;
}
else
{
validPasses++;
_assignmentContext.FilteredValue.PassCount = validPasses;
}
if ((_filter.AttributeFilter.HasElevationMappingModeFilter && _filter.AttributeFilter.ElevationMappingMode == ElevationMappingMode.MinimumElevation) ||
(_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Lowest))
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Highest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height > _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else
{
// are we only interested in first pass
if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.First)
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break; // we are out of here
}
if (!minElevCheckRequired)
{
minElevCheckRequired = true; // means we need to do an extra check below for minElevation on chosen last pass
}
if (!_haveFilteredPass)
{
_haveFilteredPass = true;
}
_tempPass = _currentPass; // good pass. Last one assigned will be latest
}
} // end in range
if (passRangeCount == _filter.AttributeFilter.PassCountRangeMax)
{
break; // we are out of here
}
} // end pass loop
if (minElevCheckRequired)
{
// If minElevCheckRequired we now have a known list of good passes to determine the lowest pass
// Rule states we walk in direction of CellPassIterator and return lowest pass while mode is minElev
// Walk through list that was constructed by CellPassIterator direction to get lowest pass
_haveFilteredPass = false;
for (var i = 0; i < passes; i++)
{
if (!filteredPassBoolArray[i])
{
continue;
}
_currentPass = filteredPassDataArray[i];
// check for min elevation mode
var internalMachineIndex = _currentPass.FilteredPass.InternalSiteModelMachineIndex;
var machine = _siteModel.Machines[internalMachineIndex];
var machineIsAnExcavator = machine.MachineType == MachineType.Excavator;
var mappingMode = _siteModel.MachinesTargetValues[internalMachineIndex].ElevationMappingModeStateEvents.GetValueAtDate(_currentPass.FilteredPass.Time, out _, ElevationMappingMode.LatestElevation);
var minimumElevationMappingModeAtCellPassTime = mappingMode == ElevationMappingMode.MinimumElevation;
if (machineIsAnExcavator && minimumElevationMappingModeAtCellPassTime)
{
if (!_firstPassMinElev)
{
_firstPassMinElev = true; // take first pass in list as lowest to begin with
_tempPass = _currentPass;
}
else if (!_haveFilteredPass || (_currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height))
{
_tempPass = _currentPass;
}
if (!_haveFilteredPass)
{
_haveFilteredPass = true;
}
}
else
{
if (_firstPassMinElev && _haveFilteredPass) // take last know lowest pass
{
break;
}
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break; // we have the pass we need
}
} // end passes
} // end min check required
} // end passes > 0
}
/// <summary>
/// Performs primary filtered iteration over cell passes in the cell being processed to determine the cell pass
/// to be selected.
/// </summary>
private void ProcessCellPasses()
{
_haveFilteredPass = false;
_firstPassMinElev = false;
while (_cellPassIterator.MayHaveMoreFilterableCellPasses() &&
_cellPassIterator.GetNextCellPass(ref _currentPass.FilteredPass))
{
FiltersValuePopulation.PopulateFilteredValues(_siteModel.MachinesTargetValues[_currentPass.FilteredPass.InternalSiteModelMachineIndex], _populationControl, ref _currentPass);
if (_filter.AttributeFilter.FilterPass(ref _currentPass, _filterAnnex))
{
if (_filter.AttributeFilter.HasElevationTypeFilter)
{
_assignmentContext.FilteredValue.PassCount = 1;
}
// Track cell passes against lowest/highest elevation criteria
if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Lowest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.Highest)
{
if (!_haveFilteredPass || _currentPass.FilteredPass.Height > _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass;
}
_haveFilteredPass = true;
}
else if (_filter.AttributeFilter.HasElevationTypeFilter && _filter.AttributeFilter.ElevationType == ElevationType.First)
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
else if (_gridDataType == GridDataType.Temperature)
{
var materialTemperature = _currentPass.FilteredPass.MaterialTemperature;
if (materialTemperature != CellPassConsts.NullMaterialTemperatureValue)
{
if (_filter.AttributeFilter.HasTemperatureRangeFilter)
{
if (Range.InRange(materialTemperature, _filter.AttributeFilter.MaterialTemperatureMin, _filter.AttributeFilter.MaterialTemperatureMax))
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
else
{
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
}
else
{
// check for min elevation mode
var internalMachineIndex = _currentPass.FilteredPass.InternalSiteModelMachineIndex;
var machine = _siteModel.Machines[internalMachineIndex];
var machineIsAnExcavator = machine.MachineType == MachineType.Excavator;
var mappingMode = _siteModel.MachinesTargetValues[internalMachineIndex].ElevationMappingModeStateEvents.GetValueAtDate(_currentPass.FilteredPass.Time, out _, ElevationMappingMode.LatestElevation);
var minimumElevationMappingModeAtCellPassTime = mappingMode == ElevationMappingMode.MinimumElevation;
if (machineIsAnExcavator && minimumElevationMappingModeAtCellPassTime)
{
if (!_firstPassMinElev)
{
_firstPassMinElev = true;
_haveFilteredPass = true;
_tempPass = _currentPass;
}
else if (_currentPass.FilteredPass.Height < _tempPass.FilteredPass.Height)
{
_tempPass = _currentPass; // take if lowest pass
}
}
else
{
// All criteria have been met for acceptance of this pass
_assignmentContext.FilteredValue.FilteredPassData = _currentPass;
_haveFilteredPass = true;
_assignmentContext.FilteredValue.PassCount = CellPassConsts.NullPassCountValue;
break;
}
}
}
}
}
/// <summary> /// Determine if a filtered CMV is valid (not null) /// </summary> /// <param name="filteredValue"></param> /// <returns></returns> public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) => false;
/*
* /// <summary>
* /// Constructor. Set the grid to CCV.
* /// </summary>
* /// <param name="owner"></param>
* /// <param name="parent"></param>
* /// <param name="level"></param>
* /// <param name="cellSize"></param>
* /// <param name="indexOriginOffset"></param>
* public ClientCMVLeafSubGrid(ISubGridTree owner, ISubGrid parent, byte level, double cellSize, uint indexOriginOffset) : base(owner, parent, level, cellSize, indexOriginOffset)
* {
* Initialise();
* }
*/
/// <summary>
/// Determine if a filtered CMV is valid (not null)
/// </summary>
/// <param name="filteredValue"></param>
/// <returns></returns>
public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) =>
_gridDataType != GridDataType.CCVPercentChange && IgnoresNullValueForLastCMV && filteredValue.FilteredPass.CCV == CellPassConsts.NullCCV;
/// <summary> /// Determine if the value proposed for assignation to a cell in this client leaf sub grid is null with respect /// to the nullability criteria of that client leaf sub grid /// </summary> /// <param name="filteredValue"></param> /// <returns></returns> public abstract bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue);
/// <summary> /// Determine if a filtered height is valid (not null) /// </summary> /// <param name="filteredValue"></param> /// <returns></returns> public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) => filteredValue.FilteredPass.Height == Consts.NullHeight;
/*
* /// <summary>
* /// Constructor. Set the grid to MDP.
* /// </summary>
* /// <param name="owner"></param>
* /// <param name="parent"></param>
* /// <param name="level"></param>
* /// <param name="cellSize"></param>
* /// <param name="indexOriginOffset"></param>
* public ClientMDPLeafSubGrid(ISubGridTree owner, ISubGrid parent, byte level, double cellSize, uint indexOriginOffset) : base(owner, parent, level, cellSize, indexOriginOffset)
* {
* Initialise();
* }
*/
/// <summary>
/// Determine if a filtered MDP is valid (not null)
/// </summary>
/// <param name="filteredValue"></param>
/// <returns></returns>
public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) => filteredValue.FilteredPass.MDP == CellPassConsts.NullMDP;
/*
* /// <summary>
* /// Constructor. Set the grid to Temperature.
* /// </summary>
* /// <param name="owner"></param>
* /// <param name="parent"></param>
* /// <param name="level"></param>
* /// <param name="cellSize"></param>
* /// <param name="indexOriginOffset"></param>
* public ClientTemperatureLeafSubGrid(ISubGridTree owner, ISubGrid parent, byte level, double cellSize, uint indexOriginOffset) : base(owner, parent, level, cellSize, indexOriginOffset)
* {
* Initialise();
* }
*/
/// <summary>
/// Determine if a filtered machine speed is valid (not null)
/// </summary>
/// <param name="filteredValue"></param>
/// <returns></returns>
public override bool AssignableFilteredValueIsNull(ref FilteredPassData filteredValue) => filteredValue.FilteredPass.MaterialTemperature == CellPassConsts.NullMaterialTemperatureValue;