public static TensorPlan CreateTensorPlanAtoO(Mpi mpi, OmegaModel model, int nTr, int nRc) { if (mpi != null && mpi.IsParallel) { var nxStart = mpi.CalcLocalNxStart(model.LateralDimensions); var nxTotalLength = mpi.CalcLocalNxLength(model.LateralDimensions); var nxCalcLength = nxTotalLength; if (nxStart >= model.Nx) { nxStart = -2 * model.Nx + nxStart; } if (nxStart == -model.Nx) { nxStart++; nxCalcLength--; } return(new TensorPlan(nxStart, nxCalcLength, nxTotalLength, nTr, nRc)); } else { var nxStart = -model.Nx + 1; var nxTotalLength = 2 * model.Nx; var nxCalcLength = nxTotalLength - 1; return(new TensorPlan(nxStart, nxCalcLength, nxTotalLength, nTr, nRc)); } }
public static Complex CalculateFieldE(OmegaModel model, decimal recieverDepth, decimal recieverThick = 0) { // c.CorrBackgroundTr is always layer with air boundary var c = PrepareContainer(model, recieverDepth); var kkr = Complex.ImaginaryOne * model.Omega * Mu0 * model.Section1D[c.CorrBackgroundRc].Zeta; var ikr = Complex.ImaginaryOne * Complex.Sqrt(kkr); var kk1 = Complex.ImaginaryOne * model.Omega * Mu0 * model.Section1D[c.CorrBackgroundTr].Zeta; var ik1 = Complex.ImaginaryOne * Complex.Sqrt(kk1); var dr1 = (double)model.GetLayerDepth(c.CorrBackgroundRc + 1); var d2 = (double)model.GetLayerDepth(c.CorrBackgroundTr + 1); var zr = (double)recieverDepth; var a = c.A[c.CorrBackgroundRc, c.CorrBackgroundTr] / c.A[c.CorrBackgroundTr, c.CorrBackgroundTr]; Complex upper; if (recieverThick == 0) { upper = Complex.Exp(ikr * zr) + c.Q [c.CorrBackgroundRc] * Complex.Exp(ikr * (2 * dr1 - zr)); } else { var z1 = zr - (double)recieverThick / 2; var z2 = zr + (double)recieverThick / 2; var u1 = Complex.Exp(ikr * z1) - c.Q [c.CorrBackgroundRc] * Complex.Exp(ikr * (2 * dr1 - z1)); var u2 = Complex.Exp(ikr * z2) - c.Q [c.CorrBackgroundRc] * Complex.Exp(ikr * (2 * dr1 - z2)); upper = (u2 - u1) / (z2 - z1) / ikr; } var lower = 1 + c.Q[c.CorrBackgroundTr] * Complex.Exp(ik1 * (2 * d2)); return(a * (upper / lower)); }
private static void NormalizeBeforeHankelForE(OmegaModel model, int corrBackgroundRc, ResultE r, ScalarPlanItem item) { var lambdas = item.Lambdas; var zetaRc2 = 2 * model.Section1D[corrBackgroundRc].Zeta; var iOmegaMu0 = Complex.ImaginaryOne * model.Omega * Mu0; for (int i = 0; i < r.U1.Length; i++) { r.U1[i] *= (iOmegaMu0 / 2); } for (int i = 0; i < r.U2.Length; i++) { r.U2[i] /= zetaRc2; } for (int i = 0; i < r.U3.Length; i++) { r.U3[i] *= lambdas[i] / zetaRc2; } for (int i = 0; i < r.U4.Length; i++) { r.U4[i] *= -lambdas[i] / zetaRc2; } for (int i = 0; i < r.U5.Length; i++) { r.U5[i] *= (lambdas[i] * lambdas[i]) / zetaRc2; } }
public AtoAGreenTensorCalculator( ILogger logger, OmegaModel model, INativeMemoryProvider memoryProvider) : base(logger, model, memoryProvider) { }
public static AuxContainer CreateContainer(OmegaModel model, decimal trDepth, decimal rcDepth) { var tr = Transmitter.NewFlat(trDepth); var rc = Receiver.NewFlat(rcDepth); return(CreateContainer(model, tr, rc)); }
private static Complex[,] CalculateA(OmegaModel model, AuxContainer c) { var result = new Complex[c.P.Length, c.P.Length]; int s = System.Math.Max(c.CorrBackgroundRc, c.CorrBackgroundTr); int r = System.Math.Min(c.CorrBackgroundRc, c.CorrBackgroundTr); for (int n = s; n >= r; n--) { Complex prevA = 1.0 / (c.Eta[n] * (1 - c.P[n] * c.Q[n] * c.Exp[n])); result[n, n] = prevA; for (int k = n - 1; k >= r; k--) { var dk1 = (double)model.GetLayerDepth(k + 1); var q = ((1 + c.P[k + 1]) / (1 + c.P[k] * c.Exp[k])) * Complex.Exp((c.Eta[k + 1] - c.Eta[k]) * dk1); Complex nextA = q * prevA; result[k, n] = nextA; result[n, k] = nextA; prevA = nextA; } } return(result); }
public static AuxContainer CreateContainer(OmegaModel model, Transmitter tr, Receiver rc) { var corrBackgroundTr = model.DetermineCorrespondingBackgroundLayer(tr.GetWorkingDepth()); var corrBackgroundRc = model.DetermineCorrespondingBackgroundLayer(rc.GetWorkingDepth()); var c = new AuxContainer(tr, rc, corrBackgroundTr, corrBackgroundRc); return(c); }
public static FftBuffer GetBuffer(OmegaModel model) { var modelSize = new ModelSize(model.Nx, model.Ny, model.Nz); if (!Buffers.ContainsKey(modelSize)) { throw new InvalidOperationException("Fft buffer does not created for this model size"); } return(Buffers[modelSize]); }
public static Complex[] CalculateExp(OmegaModel model, Complex[] eta) { var exp = new Complex[eta.Length]; for (int k = 0; k < exp.Length; k++) { var thick = model.Section1D[k].Thickness; exp[k] = Complex.Exp(-2 * eta[k] * (double)thick); } return(exp); }
public ResultsContainer SolveWithoutGather(OmegaModel model, TensorCache tensors = null) { if (tensors == null) { SolvePrivate(model, null, tensors); } else { SolvePrivate(model, tensors.gtAtoA, tensors); } return(GatherSolutionLocally()); }
public GreenTensorFftPopulator(GreenTensor greenTensor, OmegaModel model, bool symm = false) { _greenTensor = greenTensor; _nx = model.LateralDimensions.Nx; _ny = model.LateralDimensions.Ny; _nx2 = _nx * 2; _ny2 = _ny * 2; var nz = model.Anomaly.Layers.Count; _length = symm ? nz + nz * (nz - 1) / 2 : nz * nz; }
public static Complex[] CalculateEta(OmegaModel model, double lambda) { var iOmega = Complex.ImaginaryOne * model.Omega; var eta = new Complex[model.Section1D.NumberOfLayers]; for (int k = 0; k < eta.Length; k++) { var zeta = model.Section1D[k].Zeta; eta[k] = Complex.Sqrt(lambda * lambda - iOmega * zeta * Mu0); } return(eta); }
private static AuxContainer PrepareContainer(OmegaModel model, decimal recieverDepth) { var alphaBeta = AlphaBeta.CreateFrom(model.Section1D); var c = AuxContainer.CreateContainer(model, 0, recieverDepth); const double lambda = 0; c.Eta = PlanCalculator.CalculateEta(model, lambda); c.Exp = PlanCalculator.CalculateExp(model, c.Eta); c.Q = PlanCalculator.CalculateQ1(alphaBeta, c.Eta, c.Exp); c.P = PlanCalculator.CalculateP1(alphaBeta, c.Eta, c.Exp); c.A = PlanCalculator.CalculateA1(model, c); return(c); }
public static int DetermineCorrespondingBackgroundLayer(this OmegaModel model, decimal depth) { decimal prev = model.Section1D.ZeroAirLevelAlongZ; for (int k = 0; k < model.Section1D.NumberOfLayers; k++) { var d1 = prev; var d2 = prev + model.Section1D[k].Thickness; if (depth >= d1 && depth < d2) { return(k); } prev = d2; } throw new InvalidOperationException("Anomaly is not within 1D section"); }
private static Complex[,] CalculateASigma(OmegaModel model, AuxContainer c) { var a = CalculateA(model, c); int s = System.Math.Max(c.CorrBackgroundRc, c.CorrBackgroundTr); int r = System.Math.Min(c.CorrBackgroundRc, c.CorrBackgroundTr); for (int n = s; n >= r; n--) { for (int k = n - 1; k >= r; k--) { var zetaRc = model.Section1D[k].Zeta; var zetaTr = model.Section1D[n].Zeta; a[n, k] = (zetaTr / zetaRc) * a[k, n]; } } return(a); }
private void SolvePrivate(OmegaModel model, GreenTensor aToA, TensorCache tensors = null) { Logger.WriteStatus("Starting Cartesian MT Forward solver..."); using (Profiler?.StartAuto(ProfilerEvent.ForwardSolving)) { SetModel(model, tensors); if (aToA == null) { CalculateGreenTensor(); } else { SetNewGreenTensor(aToA); } SolverPolarizationX(); SolverPolarizationY(); } }
protected GreenTensorCalculator( ILogger logger, OmegaModel model, INativeMemoryProvider memoryProvider) { if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (memoryProvider == null) { throw new ArgumentNullException(nameof(memoryProvider)); } if (model == null) { throw new ArgumentNullException(nameof(model)); } Logger = logger; MemoryProvider = memoryProvider; Model = model; }
protected void SetModel(OmegaModel model, TensorCache tensors = null) { if (IsParallel) { Mpi.CheckNumberOfProcesses(model.LateralDimensions); } Model = model; if (_aToOCalculator == null) { _aToOCalculator = new AtoOCalculator(this); } if (_fgmresSolver == null) { _fgmresSolver = new AnomalyCurrentFgmresSolver(this); } if (_convolutionOperator == null) { _convolutionOperator = new ConvolutionOperator(this); } if (tensors == null) { _aToOCalculator.CleanGreenTensors(); if (!StoreAtoA) { _greenTensorAtoA?.Dispose(); _greenTensorAtoA = null; } } else { _aToOCalculator.SetTensors(tensors.eGreenTensors, tensors.hGreenTensors); SetNewGreenTensor(tensors.gtAtoA); } }
public static Complex CalculateFieldH(OmegaModel model, decimal recieverDepth) { // c.CorrBackgroundTr is always layer with air boundary var c = PrepareContainer(model, recieverDepth); var kkr = Complex.ImaginaryOne * model.Omega * Mu0 * model.Section1D[c.CorrBackgroundRc].Zeta; var ikr = Complex.ImaginaryOne * Complex.Sqrt(kkr); var kk1 = Complex.ImaginaryOne * model.Omega * Mu0 * model.Section1D[c.CorrBackgroundTr].Zeta; var ik1 = Complex.ImaginaryOne * Complex.Sqrt(kk1); var dr1 = (double)model.GetLayerDepth(c.CorrBackgroundRc + 1); var d2 = (double)model.GetLayerDepth(c.CorrBackgroundTr + 1); var zr = (double)recieverDepth; var a = c.A[c.CorrBackgroundRc, c.CorrBackgroundTr] / c.A[c.CorrBackgroundTr, c.CorrBackgroundTr]; var upper = Complex.Exp(ikr * zr) - c.Q[c.CorrBackgroundRc] * Complex.Exp(ikr * (2 * dr1 - zr)); var lower = 1 + c.Q[c.CorrBackgroundTr] * Complex.Exp(ik1 * (2 * d2)); return((Complex.Sqrt(kkr) / (model.Omega * Mu0)) * a * (upper / lower)); }
private GreenScalarCalculator( ILogger logger, OmegaModel model, FieldToField ftof, IntegrationType integrationType) { if (logger == null) { throw new ArgumentNullException(nameof(logger)); } if (model == null) { throw new ArgumentNullException(nameof(model)); } _logger = logger; _model = model; _ftof = ftof; _integrationType = integrationType; _alphaBeta = AlphaBeta.CreateFrom(model.Section1D); }
public static InnerResult NormalizeAndPerformHankel(ResultE e, ScalarPlanItem planItem, OmegaModel model, int corrBackgroundRc) { NormalizeBeforeHankelForE(model, corrBackgroundRc, e, planItem); var r = CalculateHankelForE(planItem, e); NormalizeAfterHankelForE(planItem, r); return(r); }
public static GreenScalarCalculator NewAtoOElectricCalculator(ILogger logger, OmegaModel model) => new GreenScalarCalculator(logger, model, FieldToField.J2E, IntegrationType.VolumeToPoint);
public static GreenScalarCalculator NewStoAMagneticCalculator(ILogger logger, OmegaModel model) => new GreenScalarCalculator(logger, model, FieldToField.J2H, IntegrationType.VolumeToVolume);
public static Complex[,] CalculateA1(OmegaModel model, AuxContainer c) => CalculateA(model, c);
protected abstract ICalculatorU GetCalculatorU(OmegaModel model, AuxContainer c);
protected override ICalculatorU GetCalculatorU(OmegaModel model, AuxContainer c) { return(new VolumeToPointCalculatorU(model, c)); }
public ResultsContainer Solve(OmegaModel model, GreenTensor aToA = null) { SolvePrivate(model, aToA); return(GatherSolution()); }
public VolumeToVolumeCalculatorUFast(OmegaModel model, AuxContainerFast container) { _model = model; _container = container; }
protected PlanCalculator(OmegaModel model, AlphaBeta alphaBeta, ScalarPlanItem planItem) { _model = model; _alphaBeta = alphaBeta; _planItem = planItem; }
public VolumeToPointPlanCalculator(OmegaModel model, AlphaBeta alphaBeta, ScalarPlanItem planItem) : base(model, alphaBeta, planItem) { }