public GreenTensor CalculateAtoOMagnetic(ScalarSegments segments, MemoryLayoutOrder layoutOrder, TensorPlan plan)
        {
            if (segments == null)
            {
                throw new ArgumentNullException(nameof(segments));
            }
            _plan = plan;
            _useLocalTransofrmForI = _plan.NxTotalLength == 2 * Model.Nx;

            var greenTensor = AllocateNew("xx", "yx", "xy", "xz", "yz", "zx", "zy");

            SetSegments(segments);
            SetGreenTensorAndRadii(greenTensor, segments.Radii);

            if (_plan.NxCalcLength != 0)
            {
                PrepareValuesForAtoOMagneticLevel(layoutOrder);
                PrepareKnotsAtoO(segments.Radii, _plan.NxStart, _plan.NxCalcLength);

                RunAlongXMagnetic(_plan.NxStart, _plan.NxCalcLength);
                RunAlongYMagnetic(_plan.NxStart, _plan.NxCalcLength);
            }

            return(greenTensor);
        }
示例#2
0
        private GreenTensor CalculateGreenTensorElectric(SourceLayer layer, ObservationLevel level)
        {
            var plan             = _plansCreater.CreateForSourceToObservation(layer, level);
            var transceiver      = TranceiverUtils.CreateSourceToObservations(SourceThickness, layer, level);
            var scalarCalculator = GreenScalarCalculator.NewAtoOElectricCalculator(Logger, Model);
            var scalars          = scalarCalculator.Calculate(plan, transceiver);

            using (var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, scalars))
            {
                var tensorPlan = new TensorPlan(_templateTensorPlan, layer, level);
                _gtc.ResetKnots();
                var gt = _gtc.CalculateAtoOElectric(segments, MemoryLayoutOrder.AlongVertical, tensorPlan);

                PerformGreenTensorFft(gt);
                return(gt);
            }
        }
示例#3
0
        private unsafe GreenTensor CalculateGreenTensorAtoOLevelElectric(ObservationLevel level)
        {
            using (Solver.Profiler?.StartAuto(ProfilerEvent.AtoOGreenCalc))
            {
                var plan             = _plansCreater.CreateForAnomalyToObservationLevels(level);
                var transceiver      = TranceiverUtils.CreateAnomalyToObservation(Model.Anomaly, level);
                var scalarCalculator = GreenScalarCalculator.NewAtoOElectricCalculator(Logger, Model);
                var scalars          = scalarCalculator.Calculate(plan, transceiver);

                using (var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, scalars))
                {
                    var tensorPlan = new TensorPlan(_templateTensorPlan, level);
                    _gtc.ResetKnots();
                    var gt = _gtc.CalculateAtoOElectric(segments, MemoryLayoutOrder.AlongVertical, tensorPlan);

                    PerformGreenTensorFft(gt);
                    return(gt);
                }
            }
        }
示例#4
0
 public StoOCalculator(ForwardSolver solver) : base(solver)
 {
     _templateTensorPlan = DistibutedUtils.CreateTensorPlanAtoO(Mpi, Model, 1, 1);
     _gtc          = new AtoOLevelGreenTensorCalculator(Logger, Model, MemoryProvider);
     _plansCreater = new ScalarPlansCreater(Model.LateralDimensions, HankelCoefficients.LoadN40(), Solver.Settings.NumberOfHankels);
 }