Esempio n. 1
0
        public QueryResult ExecuteAntennaQuery(AntennaQuery query)
        {
            var queryResult = new QueryResult();

            queryResult.HasResult = false;
            var results = _antennas.Values.Select(antenna => antenna.Match(query)).Where(x => x.IsMatch).OrderByDescending(x => x.IsMarginMatch).ToList();

            if (results.Count > 0)
            {
                queryResult.HasResult    = true;
                queryResult.BestMatch    = results.First();
                queryResult.OtherMatches = results.Skip(1).ToList();
            }

            return(queryResult);
        }
Esempio n. 2
0
        public MatchResult Match(AntennaQuery query)
        {
            var result = new MatchResult(this);

            result.Dimensions = GetClosestDimensionMap(DimensionMaps, query.BandRanges[0].F0_Normalized);
            var freqValueMap = GetClosestFreqValueMap(VSWRMaps, query.BandRanges[0].F0_Normalized);

            if (freqValueMap == null)
            {
                freqValueMap = GetClosestFreqValueMap(FreqGainMaps, query.BandRanges[0].F0_Normalized);
            }
            var f0_lib   = freqValueMap.F0_Normalized;
            var f0_input = query.BandRanges[0].F0_Normalized;

            result.Scale = f0_input == 0 ? 0 : f0_lib / f0_input;

            foreach (var querybandRange in query.BandRanges)
            {
                var vswrMap     = GetClosestFreqValueMap(VSWRMaps, querybandRange.F0_Normalized);
                var freqGainMap = GetClosestFreqValueMap(FreqGainMaps, querybandRange.F0_Normalized);

                // BandWidth
                if (vswrMap != null)
                {
                    if (vswrMap.BandWidth < querybandRange.BandWidth)
                    {
                        return(result);
                    }
                }
                else if (freqGainMap != null)
                {
                    if (freqGainMap.BandWidth < querybandRange.BandWidth)
                    {
                        return(result);
                    }
                }

                var thetaGainMap = GetClosesThetaValueMap(ThetaGainMaps, querybandRange.F0_Normalized);

                // Gain
                if (query.Gain != null)
                {
                    if (freqGainMap != null)
                    {
                        if (freqGainMap.GetValueByFreq(querybandRange.F0_Normalized) < query.Gain.Value)
                        {
                            return(result);
                        }

                        // Marginal gain
                        if (freqGainMap.GetValueByFreq(querybandRange.LowerBound.NormalizedFreq) < query.Gain.Value || freqGainMap.GetValueByFreq(querybandRange.UpperBound.NormalizedFreq) < query.Gain.Value)
                        {
                            result.IsMarginMatch = false;
                            return(result);
                        }
                    }
                    else if (thetaGainMap != null && thetaGainMap.MaxValue < query.Gain.Value)
                    {
                        return(result);
                    }
                }

                // 3dB Width
                if (query._3dBWidth != null && thetaGainMap != null && (double)Math.Abs(thetaGainMap._3dBWidth - query._3dBWidth.Value) / (double)query._3dBWidth > 0.05)
                {
                    return(result);
                }

                // VSWR
                if (query.VSWR != null && vswrMap != null && vswrMap.GetValueByFreq(querybandRange.F0_Normalized) > query.VSWR.Value * 1.1)
                {
                    return(result);
                }

                if (query.AxialRatio != null)
                {
                    var arMap = GetClosestFreqValueMap(AxialRatioMaps, querybandRange.F0_Normalized);
                    if (arMap != null)
                    {
                        if (arMap.GetValueByFreq(querybandRange.F0_Normalized) < query.AxialRatio.Value)
                        {
                            return(result);
                        }

                        // Marginal gain
                        if (arMap.GetValueByFreq(querybandRange.LowerBound.NormalizedFreq) < query.AxialRatio.Value || arMap.GetValueByFreq(querybandRange.UpperBound.NormalizedFreq) < query.AxialRatio.Value)
                        {
                            result.IsMarginMatch = false;
                            return(result);
                        }
                    }
                }

                // Cross Polarization
                var crossPolarizationMap = GetClosesThetaValueMap(CrossPolarizationMaps, querybandRange.F0_Normalized);
                if (query.CrossPolarization != null && crossPolarizationMap != null && crossPolarizationMap.MaxValue < query.CrossPolarization.Value)
                {
                    return(result);
                }
            }

            // Polarization
            if (query.Polarizations != null)
            {
                foreach (var polarization in query.Polarizations)
                {
                    if (!Tags.Contains(polarization, StringComparer.InvariantCultureIgnoreCase))
                    {
                        return(result);
                    }
                }
            }

            if (query.Efficiency != null && Efficiency != null && Efficiency < query.Efficiency)
            {
                return(result);
            }


            // TODO: Axial Ratio


            result.IsMatch = true;
            return(result);
        }