Beispiel #1
0
 /// <summary>
 /// Creates a new builder responsible for determining a vector of cells that are crossed by a profile line
 /// </summary>
 public ICellProfileBuilder <T> NewCellProfileBuilder(ISiteModel siteModel,
                                                      IFilterSet filterSet,
                                                      IDesignWrapper cutFillDesignWrapper,
                                                      bool slicerToolUsed)
 {
     return(new CellProfileBuilder <T>(siteModel, filterSet, cutFillDesignWrapper, slicerToolUsed));
 }
Beispiel #2
0
        /// <summary>
        /// Constructs a cell profile analyzer that analyzes cells in a cell profile vector
        /// </summary>
        /// <param name="siteModel"></param>
        /// <param name="pDExistenceMap"></param>
        /// <param name="filterSet"></param>
        /// <param name="cellLiftBuilder"></param>
        /// <param name="overrides"></param>
        public CellProfileAnalyzer(ISiteModel siteModel,
                                   ISubGridTreeBitMask pDExistenceMap,
                                   IFilterSet filterSet,
                                   ICellLiftBuilder cellLiftBuilder,
                                   IOverrideParameters overrides,
                                   ILiftParameters liftParams)
            : base(siteModel, pDExistenceMap, filterSet, overrides, liftParams)
        {
            CellLiftBuilder = cellLiftBuilder;

            PassFilter = filterSet.Filters[0].AttributeFilter;
            if (PassFilter.HasElevationRangeFilter && PassFilter.ElevationRangeDesign.DesignID != Guid.Empty)
            {
                var design = siteModel.Designs.Locate(PassFilter.ElevationRangeDesign.DesignID);
                if (design == null)
                {
                    Log.LogError($"ElevationRangeDesign {PassFilter.ElevationRangeDesign.DesignID} is unknown in project {siteModel.ID}");
                }
                else
                {
                    PassFilterElevationRangeDesign = new DesignWrapper(PassFilter.ElevationRangeDesign, design);
                }
            }
            PassFilterAnnex = new CellPassAttributeFilterProcessingAnnex();
            CellFilter      = filterSet.Filters[0].SpatialFilter;
        }
Beispiel #3
0
        /// <summary>
        /// Executor that implements requesting and rendering sub grid information to create the cell datum
        /// </summary>
        public async Task <CellDatumResponse_ClusterCompute> ExecuteAsync(CellDatumRequestArgument_ClusterCompute arg, SubGridSpatialAffinityKey key)
        {
            Log.LogInformation($"Performing Execute for DataModel:{arg.ProjectID}, Mode={arg.Mode}");

            var result = new CellDatumResponse_ClusterCompute {
                ReturnCode = CellDatumReturnCode.UnexpectedError
            };

            var siteModel = DIContext.Obtain <ISiteModels>().GetSiteModel(arg.ProjectID);

            if (siteModel == null)
            {
                Log.LogError($"Failed to locate site model {arg.ProjectID}");
                return(result);
            }

            IDesignWrapper cutFillDesign = null;

            if (arg.ReferenceDesign != null && arg.ReferenceDesign.DesignID != Guid.Empty)
            {
                var design = siteModel.Designs.Locate(arg.ReferenceDesign.DesignID);
                if (design == null)
                {
                    throw new ArgumentException($"Design {arg.ReferenceDesign.DesignID} not a recognized design in project {arg.ProjectID}");
                }
                cutFillDesign = new DesignWrapper(arg.ReferenceDesign, design);
            }

            await GetProductionData(siteModel, cutFillDesign, result, arg);

            return(result);
        }
Beispiel #4
0
        /// <summary>
        /// Creates a CellProfile builder given a list of coordinates defining the path to profile and a container to place the resulting cells into
        /// </summary>
        /// <param name="siteModel"></param>
        /// <param name="filterSet"></param>
        /// <param name="cutFillDesignWrapper"></param>
        /// <param name="slicerToolUsed"></param>
        public CellProfileBuilder(ISiteModel siteModel,
                                  IFilterSet filterSet,
                                  IDesignWrapper cutFillDesignWrapper,
                                  bool slicerToolUsed)
        {
            SiteModel            = siteModel;
            CellFilter           = filterSet?.Filters[0].SpatialFilter;
            CutFillDesignWrapper = cutFillDesignWrapper;
            SlicerToolUsed       = slicerToolUsed;

            Initialise();
        }
Beispiel #5
0
 /// <summary>
 /// Constructs a profile lift builder that analyzes cells in a cell profile vector
 /// </summary>
 public SummaryVolumesCellProfileAnalyzer(ISiteModel siteModel,
                                          ISubGridTreeBitMask pDExistenceMap,
                                          IFilterSet filterSet,
                                          IDesignWrapper referenceDesignWrapper,
                                          ICellLiftBuilder cellLiftBuilder,
                                          VolumeComputationType volumeType,
                                          IOverrideParameters overrides,
                                          ILiftParameters liftParams)
     : base(siteModel, pDExistenceMap, filterSet, overrides, liftParams)
 {
     svDesignWrapper = referenceDesignWrapper;
     VolumeType      = volumeType;
 }
Beispiel #6
0
        private StationOffsetRow ExtractRequiredValues(IDesignWrapper cutFillDesignWrapper, StationOffsetPoint point, ClientCellProfileLeafSubgrid clientGrid, int cellX, int cellY)
        {
            clientGrid.CalculateWorldOrigin(out double subgridWorldOriginX, out double subgridWorldOriginY);
            var cell = clientGrid.Cells[cellX, cellY];

            var result = new StationOffsetRow(point.Station, point.Offset, cell.CellYOffset + subgridWorldOriginY, cell.CellXOffset + subgridWorldOriginX);

            (IClientHeightLeafSubGrid designHeights, DesignProfilerRequestResult errorCode)getDesignHeightsResult = (null, DesignProfilerRequestResult.UnknownError);

            if (requestArgument.ReferenceDesign != null && requestArgument.ReferenceDesign.DesignID != Guid.Empty)
            {
                getDesignHeightsResult = cutFillDesignWrapper.Design.GetDesignHeightsViaLocalCompute(siteModel, cutFillDesignWrapper.Offset, clientGrid.OriginAsCellAddress(), clientGrid.CellSize);

                if (getDesignHeightsResult.errorCode != DesignProfilerRequestResult.OK || getDesignHeightsResult.designHeights == null)
                {
                    string errorMessage;
                    if (getDesignHeightsResult.errorCode == DesignProfilerRequestResult.NoElevationsInRequestedPatch)
                    {
                        errorMessage = "StationOffset Report. Call to RequestDesignElevationPatch failed due to no elevations in requested patch.";
                        Log.LogInformation(errorMessage);
                    }
                    else
                    {
                        errorMessage = $"StationOffset Report. Call to RequestDesignElevationPatch failed due to no TDesignProfilerRequestResult return code {getDesignHeightsResult.errorCode}.";
                        Log.LogWarning(errorMessage);
                    }
                }
            }

            if (cell.PassCount == 0) // Nothing for us to do, as cell is not in our areaControlSet...
            {
                return(result);
            }

            result.Elevation = requestArgument.ReportElevation ? cell.Height : Consts.NullHeight;
            result.CutFill   = (requestArgument.ReportCutFill && (getDesignHeightsResult.designHeights != null) &&
                                getDesignHeightsResult.designHeights.Cells[cellX, cellY] != Consts.NullHeight)
        ? cell.Height - getDesignHeightsResult.designHeights.Cells[cellX, cellY]
        : Consts.NullHeight;

            // CCV is equiv to CMV in this instance
            result.Cmv         = (short)(requestArgument.ReportCmv ? cell.LastPassValidCCV : CellPassConsts.NullCCV);
            result.Mdp         = (short)(requestArgument.ReportMdp ? cell.LastPassValidMDP : CellPassConsts.NullMDP);
            result.PassCount   = (short)(requestArgument.ReportPassCount ? cell.PassCount : CellPassConsts.NullPassCountValue);
            result.Temperature = (short)(requestArgument.ReportTemperature ? cell.LastPassValidTemperature : CellPassConsts.NullMaterialTemperatureValue);

            return(result);
        }
Beispiel #7
0
        /// <summary>
        /// Gets the production data values for the requested cell
        /// </summary>
        private async Task GetProductionData(ISiteModel siteModel, IDesignWrapper cutFillDesign, CellDatumResponse_ClusterCompute result, CellDatumRequestArgument_ClusterCompute arg)
        {
            var existenceMap = siteModel.ExistenceMap;

            var utilities  = DIContext.Obtain <IRequestorUtilities>();
            var requestors = utilities.ConstructRequestors(null, siteModel, arg.Overrides, arg.LiftParams,
                                                           utilities.ConstructRequestorIntermediaries(siteModel, arg.Filters, true, GridDataType.CellProfile),
                                                           AreaControlSet.CreateAreaControlSet(), existenceMap);

            // Get the sub grid relative cell location
            int cellX = arg.OTGCellX & SubGridTreeConsts.SubGridLocalKeyMask;
            int cellY = arg.OTGCellY & SubGridTreeConsts.SubGridLocalKeyMask;

            // Reach into the sub-grid request layer and retrieve an appropriate sub-grid
            var cellOverrideMask = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Unfilled);

            cellOverrideMask.SetBit(cellX, cellY);
            requestors[0].CellOverrideMask = cellOverrideMask;

            // using the cell address get the index of cell in clientGrid
            var thisSubGridOrigin            = new SubGridCellAddress(arg.OTGCellX, arg.OTGCellY);
            var requestSubGridInternalResult = requestors[0].RequestSubGridInternal(thisSubGridOrigin, true, true);

            if (requestSubGridInternalResult.requestResult != ServerRequestResult.NoError)
            {
                if (requestSubGridInternalResult.requestResult == ServerRequestResult.SubGridNotFound)
                {
                    result.ReturnCode = CellDatumReturnCode.NoValueFound;
                }
                else
                {
                    Log.LogError($"Request for sub grid {thisSubGridOrigin} request failed with code {requestSubGridInternalResult.requestResult}");
                }
                return;
            }

            var cell = ((ClientCellProfileLeafSubgrid)requestSubGridInternalResult.clientGrid).Cells[cellX, cellY];

            if (cell.PassCount > 0) // Cell is not in our areaControlSet...
            {
                await ExtractRequiredValue(cutFillDesign, cell, result, arg);

                result.TimeStampUTC = cell.LastPassTime;
            }
        }
Beispiel #8
0
        /// <summary>
        /// Configures a new profile builder that provides the three core builders used in profiling: construction of cell vector from profile line,
        /// profile analysis orchestration and per cell layer/statistics calculation
        /// </summary>
        public void Configure(ProfileStyle profileStyle,
                              ISiteModel siteModel,
                              ISubGridTreeBitMask productionDataExistenceMap,
                              GridDataType gridDataType,
                              IFilterSet filterSet,
                              IDesignWrapper referenceDesignWrapper,
                              IFilteredValuePopulationControl PopulationControl,
                              ICellPassFastEventLookerUpper CellPassFastEventLookerUpper,
                              VolumeComputationType volumeType,
                              IOverrideParameters overrides,
                              ILiftParameters liftParams,
                              bool slicerToolUsed = true)
        {
            CellLiftBuilder = factory.NewCellLiftBuilder(siteModel, gridDataType, PopulationControl, filterSet, CellPassFastEventLookerUpper);

            CellProfileBuilder = factory.NewCellProfileBuilder(siteModel, filterSet, referenceDesignWrapper, slicerToolUsed);

            CellProfileAnalyzer = factory.NewCellProfileAnalyzer(
                profileStyle, siteModel, productionDataExistenceMap, filterSet,
                referenceDesignWrapper, CellLiftBuilder, volumeType, overrides, liftParams);
        }
Beispiel #9
0
        /// <summary>
        /// Creates a new builder responsible for analyzing profile information for a cell or cells identified along a profile line
        /// </summary>
        public ICellProfileAnalyzer <T> NewCellProfileAnalyzer(ProfileStyle profileStyle,
                                                               ISiteModel siteModel,
                                                               ISubGridTreeBitMask pDExistenceMap,
                                                               IFilterSet filterSet,
                                                               IDesignWrapper referenceDesignWrapper,
                                                               ICellLiftBuilder cellLiftBuilder,
                                                               VolumeComputationType volumeComputationType,
                                                               IOverrideParameters overrides,
                                                               ILiftParameters liftParams)
        {
            switch (profileStyle)
            {
            case ProfileStyle.CellPasses:
                return(DIContext.Obtain <Func <ISiteModel, ISubGridTreeBitMask, IFilterSet, ICellLiftBuilder, IOverrideParameters, ILiftParameters, ICellProfileAnalyzer <T> > >()
                           (siteModel, pDExistenceMap, filterSet, cellLiftBuilder, overrides, liftParams));

            case ProfileStyle.SummaryVolume:
                return(DIContext.Obtain <Func <ISiteModel, ISubGridTreeBitMask, IFilterSet, IDesignWrapper, ICellLiftBuilder, VolumeComputationType, IOverrideParameters, ILiftParameters, ICellProfileAnalyzer <T> > >()
                           (siteModel, pDExistenceMap, filterSet, referenceDesignWrapper, cellLiftBuilder, volumeComputationType, overrides, liftParams));

            default:
                throw new ArgumentOutOfRangeException(nameof(profileStyle), profileStyle, null);
            }
        }
Beispiel #10
0
        /// <summary>
        /// Calculates a cut/fill sub grid from a production data elevation sub grid and an elevation sub grid computed from a referenced design,
        /// replacing the elevations in the first sub grid with the resulting cut fill values
        /// </summary>
        public static (bool executionResult, DesignProfilerRequestResult profilerRequestResult) ComputeCutFillSubGrid(ISiteModel siteModel, IClientLeafSubGrid SubGrid, IDesignWrapper designWrapper)
        {
            (bool executionResult, DesignProfilerRequestResult profilerRequestResult)result = (false, DesignProfilerRequestResult.UnknownError);

            if (designWrapper?.Design == null)
            {
                return(result);
            }

            var getDesignHeightsResult = designWrapper.Design.GetDesignHeightsViaLocalCompute(siteModel, designWrapper.Offset, SubGrid.OriginAsCellAddress(), SubGrid.CellSize);

            result.profilerRequestResult = getDesignHeightsResult.errorCode;

            if (result.profilerRequestResult != DesignProfilerRequestResult.OK && result.profilerRequestResult != DesignProfilerRequestResult.NoElevationsInRequestedPatch)
            {
                _log.LogError($"Design profiler sub grid elevation request for {SubGrid.OriginAsCellAddress()} failed with error {result.profilerRequestResult}");
                return(result);
            }

            ComputeCutFillSubGrid((IClientHeightLeafSubGrid)SubGrid, getDesignHeightsResult.designHeights);

            result.executionResult = true;
            return(result);
        }
Beispiel #11
0
        /// <summary>
        /// For each point in the list, get the sub grid and extract productionData at the station/offset i.e pointOfInterest
        ///    This could be optimized to get any poi from each sub grid before disposal
        /// </summary>
        private StationOffsetReportRequestResponse_ClusterCompute GetProductionData()
        {
            var result = new StationOffsetReportRequestResponse_ClusterCompute {
                ResultStatus = RequestErrorStatus.Unknown
            };

            IDesignWrapper cutFillDesignWrapper = null;

            if (requestArgument.ReferenceDesign != null && requestArgument.ReferenceDesign.DesignID != Guid.Empty)
            {
                var cutFillDesign = siteModel.Designs.Locate(requestArgument.ReferenceDesign.DesignID);
                if (cutFillDesign == null)
                {
                    throw new ArgumentException($"Design {requestArgument.ReferenceDesign.DesignID} not a recognized design in project {requestArgument.ProjectID}");
                }
                cutFillDesignWrapper = new DesignWrapper(requestArgument.ReferenceDesign, cutFillDesign);
            }

            var existenceMap = siteModel.ExistenceMap;
            var utilities    = DIContext.Obtain <IRequestorUtilities>();
            var requestors   = utilities.ConstructRequestors(null, siteModel, requestArgument.Overrides, requestArgument.LiftParams,
                                                             utilities.ConstructRequestorIntermediaries(siteModel, requestArgument.Filters, true, GridDataType.CellProfile),
                                                             AreaControlSet.CreateAreaControlSet(), existenceMap);

            // Obtain the primary partition map to allow this request to determine the elements it needs to process
            bool[] primaryPartitionMap = ImmutableSpatialAffinityPartitionMap.Instance().PrimaryPartitions();
            SubGridTreeBitmapSubGridBits cellOverrideMask = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Unfilled);

            foreach (var point in requestArgument.Points)
            {
                // Determine the on-the-ground cell
                siteModel.Grid.CalculateIndexOfCellContainingPosition(point.Easting, point.Northing, out int OTGCellX, out int OTGCellY);

                var thisSubGridOrigin = new SubGridCellAddress(OTGCellX, OTGCellY);

                if (!primaryPartitionMap[thisSubGridOrigin.ToSpatialPartitionDescriptor()])
                {
                    continue;
                }

                // Get the sub grid relative cell location
                int cellX = OTGCellX & SubGridTreeConsts.SubGridLocalKeyMask;
                int cellY = OTGCellY & SubGridTreeConsts.SubGridLocalKeyMask;

                // Reach into the sub-grid request layer and retrieve an appropriate sub-grid
                cellOverrideMask.Clear();
                cellOverrideMask.SetBit(cellX, cellY);
                requestors[0].CellOverrideMask = cellOverrideMask;

                // using the cell address get the index of cell in clientGrid
                var requestSubGridInternalResult = requestors[0].RequestSubGridInternal(
                    thisSubGridOrigin, true, true);

                if (requestSubGridInternalResult.requestResult != ServerRequestResult.NoError)
                {
                    Log.LogError($"Request for sub grid {thisSubGridOrigin} request failed with code {result}");
                    result.StationOffsetRows.Add(new StationOffsetRow(point.Station, point.Offset, point.Northing, point.Easting));
                    continue;
                }

                var hydratedPoint = ExtractRequiredValues(cutFillDesignWrapper, point, requestSubGridInternalResult.clientGrid as ClientCellProfileLeafSubgrid, cellX, cellY);
                result.StationOffsetRows.Add(hydratedPoint);
            }

            result.ResultStatus = RequestErrorStatus.OK;
            return(result);
        }
Beispiel #12
0
        /// <summary>
        /// Executes the profiler logic in the cluster compute context where each cluster node processes its fraction of the work and returns the
        /// results to the application service context
        /// </summary>
        public async Task <ProfileRequestResponse <T> > ExecuteAsync()
        {
            LiftParams.CCVSummaryTypes |= CCVSummaryTypes.Compaction;
            LiftParams.MDPSummaryTypes |= MDPSummaryTypes.Compaction;

            ProfileRequestResponse <T> Response = null;

            try
            {
                var ProfileCells = new List <T>(INITIAL_PROFILE_LIST_SIZE);

                try
                {
                    // Note: Start/end point lat/lon fields have been converted into grid local coordinate system by this point
                    if (NEECoords.Length > 1)
                    {
                        Log.LogInformation($"#In#: DataModel {ProjectID}, Vertices:{NEECoords[0]} -> {NEECoords[1]}");
                    }
                    else
                    {
                        Log.LogWarning($"#In#: DataModel {ProjectID}, Note! vertices list has insufficient vertices (min of 2 required)");
                    }

                    SiteModel = DIContext.Obtain <ISiteModels>().GetSiteModel(ProjectID);

                    if (SiteModel == null)
                    {
                        Log.LogWarning($"Failed to locate site model {ProjectID}");
                        return(Response = new ProfileRequestResponse <T> {
                            ResultStatus = RequestErrorStatus.NoSuchDataModel
                        });
                    }

                    // Obtain the sub grid existence map for the project
                    var ProdDataExistenceMap = SiteModel.ExistenceMap;

                    var PopulationControl = new FilteredValuePopulationControl();
                    PopulationControl.PreparePopulationControl(ProfileTypeRequired, LiftParams, Filters.Filters[0].AttributeFilter);

                    IDesignWrapper designWrapper = null;
                    if (Design != null && Design.DesignID != Guid.Empty)
                    {
                        var design = SiteModel.Designs.Locate(Design.DesignID);
                        if (design == null)
                        {
                            throw new ArgumentException($"Design {Design.DesignID} is unknown in project {SiteModel.ID}");
                        }
                        designWrapper = new DesignWrapper(Design, design);
                    }

                    Log.LogInformation("Creating IProfileBuilder");
                    var Profiler = DIContext.Obtain <IProfilerBuilder <T> >();
                    if (Profiler == null)
                    {
                        Log.LogWarning($"Failed to create IProfileBuilder via DI");
                        return(Response = new ProfileRequestResponse <T> {
                            ResultStatus = RequestErrorStatus.FailedOnRequestProfile
                        });
                    }

                    Profiler.Configure(ProfileStyle, SiteModel, ProdDataExistenceMap, ProfileTypeRequired, Filters,
                                       designWrapper, PopulationControl,
                                       new CellPassFastEventLookerUpper(SiteModel), VolumeType, Overrides, LiftParams);

                    Log.LogInformation("Building cell profile");
                    if (Profiler.CellProfileBuilder.Build(NEECoords, ProfileCells))
                    {
                        SetupForCellPassStackExamination(Filters.Filters[0].AttributeFilter);

                        Log.LogInformation("Building lift profile");
                        if (Profiler.CellProfileAnalyzer.Analyze(ProfileCells, CellPassIterator))
                        {
                            Log.LogInformation("Lift profile building succeeded");

                            // Remove null cells in the profiles list. NUll cells are defined by cells with null CellLastHeight.
                            // All duplicate null cells will be replaced by a by single null cell entry
                            var ThinnedProfileCells = ProfileCells.Where((x, i) =>
                                                                         i == 0 || !ProfileCells[i].IsNull() || (ProfileCells[i].IsNull() && !ProfileCells[i - 1].IsNull())).ToList();

                            Response = new ProfileRequestResponse <T>
                            {
                                ProfileCells = ThinnedProfileCells,
                                ResultStatus = RequestErrorStatus.OK
                            };

                            return(Response);
                        }

                        Log.LogInformation("Lift profile building failed");
                    }
                }
                finally
                {
                    Log.LogInformation($"#Out# Execute: DataModel {ProjectID} complete for profile line. #Result#:{Response?.ResultStatus ?? RequestErrorStatus.Exception} with {Response?.ProfileCells?.Count ?? 0} vertices");
                }
            }
            catch (Exception E)
            {
                Log.LogError(E, "Execute: Exception:");
            }

            return(new ProfileRequestResponse <T>());
        }
Beispiel #13
0
        InitialiseFilterContext(ISiteModel siteModel, ICellPassAttributeFilter passFilter,
                                ICellPassAttributeFilterProcessingAnnex passFilterAnnex, ProfileCell profileCell, IDesignWrapper passFilterElevRangeDesign)
        {
            (bool executionResult, DesignProfilerRequestResult filterDesignErrorCode)result = (false, DesignProfilerRequestResult.UnknownError);

            // If the elevation range filter uses a design then the design elevations
            // for the sub grid need to be calculated and supplied to the filter

            if (passFilter.HasElevationRangeFilter && passFilterElevRangeDesign != null)
            {
                var getDesignHeightsResult = passFilterElevRangeDesign.Design.GetDesignHeightsViaLocalCompute(siteModel, passFilterElevRangeDesign.Offset, new SubGridCellAddress(profileCell.OTGCellX, profileCell.OTGCellY), siteModel.CellSize);

                result.filterDesignErrorCode = getDesignHeightsResult.errorCode;

                if (result.filterDesignErrorCode != DesignProfilerRequestResult.OK || getDesignHeightsResult.designHeights == null)
                {
                    if (result.filterDesignErrorCode == DesignProfilerRequestResult.NoElevationsInRequestedPatch)
                    {
                        _log.LogInformation(
                            "Lift filter by design. Call to RequestDesignElevationPatch failed due to no elevations in requested patch.");
                    }
                    else
                    {
                        _log.LogWarning(
                            $"Lift filter by design. Call to RequestDesignElevationPatch failed due to no TDesignProfilerRequestResult return code {result.filterDesignErrorCode}.");
                    }
                    return(result);
                }

                passFilterAnnex.InitializeElevationRangeFilter(passFilter, getDesignHeightsResult.designHeights.Cells);
            }

            result.executionResult = true;
            return(result);
        }
Beispiel #14
0
        /// <summary>
        /// Gets the required datum from the cell according to the requested display mode
        /// </summary>
        private async Task ExtractRequiredValue(IDesignWrapper cutFillDesign, ClientCellProfileLeafSubgridRecord cell, CellDatumResponse_ClusterCompute result, CellDatumRequestArgument_ClusterCompute arg)
        {
            var success = false;
            int intValue;

            switch (arg.Mode)
            {
            case DisplayMode.Height:
                result.Value = cell.Height;
                success      = result.Value != CellPassConsts.NullHeight;
                break;

            case DisplayMode.CCV:
            case DisplayMode.CompactionCoverage:
                result.Value = cell.LastPassValidCCV;
                success      = result.Value != CellPassConsts.NullCCV;
                break;

            case DisplayMode.CCVPercent:
            case DisplayMode.CCVSummary:
            case DisplayMode.CCVPercentSummary:
                result.Value = 0; // default - no value...
                intValue     = arg.Overrides.OverrideMachineCCV ? arg.Overrides.OverridingMachineCCV : cell.TargetCCV;
                if (intValue != 0)
                {
                    success = cell.LastPassValidCCV != CellPassConsts.NullCCV && intValue != CellPassConsts.NullCCV;
                    if (success)
                    {
                        result.Value = ((double)cell.LastPassValidCCV / intValue) * 100;
                    }
                }
                break;

            case DisplayMode.PassCount:
                result.Value = cell.PassCount;
                success      = result.Value != CellPassConsts.NullPassCountValue;
                break;

            case DisplayMode.PassCountSummary:
                result.Value = 0; // default - no value...
                if (arg.Overrides.OverrideTargetPassCount)
                {
                    if (cell.PassCount > arg.Overrides.OverridingTargetPassCountRange.Max)
                    {
                        intValue = arg.Overrides.OverridingTargetPassCountRange.Max;
                    }
                    else if (cell.PassCount < arg.Overrides.OverridingTargetPassCountRange.Min)
                    {
                        intValue = arg.Overrides.OverridingTargetPassCountRange.Min;
                    }
                    else
                    {
                        intValue = cell.PassCount;
                    }
                }
                else
                {
                    intValue = cell.TargetPassCount;
                }
                if (intValue != 0)
                {
                    success = cell.PassCount != CellPassConsts.NullPassCountValue;
                    if (success)
                    {
                        result.Value = ((double)cell.PassCount / intValue) * 100;
                    }
                }
                break;

            case DisplayMode.CutFill:
                result.Value = cell.Height;
                if (cutFillDesign != null)
                {
                    var designSpotHeightResult = await cutFillDesign.Design.GetDesignSpotHeight(arg.ProjectID, cutFillDesign.Offset, arg.NEECoords.X, arg.NEECoords.Y);

                    if (designSpotHeightResult.errorCode == DesignProfilerRequestResult.OK && designSpotHeightResult.spotHeight != CellPassConsts.NullHeight)
                    {
                        result.Value = result.Value - designSpotHeightResult.spotHeight;
                        success      = true;
                    }
                }
                break;

            case DisplayMode.TemperatureSummary:
            case DisplayMode.TemperatureDetail:
                result.Value = cell.LastPassValidTemperature;
                success      = cell.LastPassValidTemperature != CellPassConsts.NullMaterialTemperatureValue;
                if (success)
                {
                    result.Value = cell.LastPassValidTemperature / 10.0; // temp is stored a int a 1 point precision
                }
                break;

            case DisplayMode.MDP:
                result.Value = cell.LastPassValidMDP;
                success      = result.Value != CellPassConsts.NullMDP;
                break;

            case DisplayMode.MDPSummary:
            case DisplayMode.MDPPercent:
            case DisplayMode.MDPPercentSummary:
                result.Value = 0; // default - no value...
                intValue     = arg.Overrides.OverrideMachineMDP ? arg.Overrides.OverridingMachineMDP : cell.TargetMDP;
                if (intValue != 0)
                {
                    success = cell.LastPassValidMDP != CellPassConsts.NullMDP && intValue != CellPassConsts.NullMDP;
                    if (success)
                    {
                        result.Value = ((double)cell.LastPassValidMDP / intValue) * 100;
                    }
                }
                break;

            case DisplayMode.MachineSpeed:
                result.Value = cell.MachineSpeed;
                success      = cell.MachineSpeed != Consts.NullMachineSpeed;
                break;

            case DisplayMode.CCVPercentChange:
            case DisplayMode.CMVChange:
                result.Value = cell.CCVChange;
                success      = cell.CCVChange != CellPassConsts.NullCCV;
                break;

            case DisplayMode.Latency:
            case DisplayMode.RMV:
            case DisplayMode.Frequency:
            case DisplayMode.Amplitude:
            case DisplayMode.Moisture:
            case DisplayMode.GPSMode:
            case DisplayMode.VolumeCoverage:
                break;
            }

            result.ReturnCode = success ? CellDatumReturnCode.ValueFound : CellDatumReturnCode.NoValueFound;
        }
Beispiel #15
0
        /// <summary>
        /// Constructor that accepts the common parameters around a set of sub grids the requester will be asked to process
        /// and initializes the requester state ready to start processing individual sub grid requests.
        /// </summary>
        public void Initialize(ISubGridsRequestArgument subGridsRequestArgument,
                               ISiteModel siteModel,
                               GridDataType gridDataType,
                               IStorageProxy storageProxy,
                               ICombinedFilter filter,
                               bool hasOverrideSpatialCellRestriction,
                               BoundingIntegerExtent2D overrideSpatialCellRestriction,
                               int maxNumberOfPassesToReturn,
                               AreaControlSet areaControlSet,
                               IFilteredValuePopulationControl populationControl,
                               ISubGridTreeBitMask pdExistenceMap,
                               ITRexSpatialMemoryCache subGridCache,
                               ITRexSpatialMemoryCacheContext[] subGridCacheContexts,
                               ISurveyedSurfaces filteredSurveyedSurfaces,
                               ISurfaceElevationPatchRequest surfaceElevationPatchRequest,
                               IOverrideParameters overrides,
                               ILiftParameters liftParams)
        {
            _siteModel    = siteModel;
            _gridDataType = gridDataType;
            _filter       = filter;

            _hasOverrideSpatialCellRestriction = hasOverrideSpatialCellRestriction;
            _overrideSpatialCellRestriction    = overrideSpatialCellRestriction;

            _retriever = DIContext.Obtain <ISubGridRetrieverFactory>().Instance(subGridsRequestArgument,
                                                                                siteModel,
                                                                                gridDataType,
                                                                                storageProxy,
                                                                                filter,
                                                                                _filterAnnex,
                                                                                hasOverrideSpatialCellRestriction,
                                                                                overrideSpatialCellRestriction,
                                                                                maxNumberOfPassesToReturn,
                                                                                areaControlSet,
                                                                                populationControl,
                                                                                pdExistenceMap,
                                                                                subGridCacheContexts,
                                                                                overrides,
                                                                                liftParams);

            _returnEarliestFilteredCellPass = _filter.AttributeFilter.ReturnEarliestFilteredCellPass;
            _processingMap = new SubGridTreeBitmapSubGridBits(SubGridBitsCreationOptions.Unfilled);

            _surfaceElevationPatchRequest = surfaceElevationPatchRequest;

            _subGridCache         = subGridCache;
            _subGridCacheContexts = subGridCacheContexts;

            _surveyedSurfacePatchType = _filter.AttributeFilter.ReturnEarliestFilteredCellPass ? SurveyedSurfacePatchType.EarliestSingleElevation : SurveyedSurfacePatchType.LatestSingleElevation;

            _filteredSurveyedSurfaces = filteredSurveyedSurfaces;
            _filteredSurveyedSurfaces?.SortChronologically(_surveyedSurfacePatchType == SurveyedSurfacePatchType.LatestSingleElevation);
            _filteredSurveyedSurfacesAsGuidArray = _filteredSurveyedSurfaces?.Select(x => x.ID).ToArray() ?? new Guid[0];

            var elevRangeDesignFilter = _filter.AttributeFilter.ElevationRangeDesign;

            if (elevRangeDesignFilter.DesignID != Guid.Empty)
            {
                var design = _siteModel.Designs.Locate(elevRangeDesignFilter.DesignID);
                if (design == null)
                {
                    _log.LogError($"ElevationRangeDesign {elevRangeDesignFilter.DesignID} is unknown in project {siteModel.ID}");
                }
                else
                {
                    _elevationRangeDesign = new DesignWrapper(elevRangeDesignFilter, design);
                }
            }

            if (_filter.SpatialFilter.IsDesignMask)
            {
                _surfaceDesignMaskDesign = _siteModel.Designs.Locate(_filter.SpatialFilter.SurfaceDesignMaskDesignUid);
            }

            _filter.AttributeFilter.SiteModel = _siteModel;
        }