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)
{
}
