public static void PrintZ(AnomalyCurrent ac, MemoryLayoutOrder layoutOrder, int k)
{
ac.LayoutOrder = layoutOrder;
Console.WriteLine("Z");
Print(ac, VerticalLayerAccessor.NewZ(ac, k));
}
private void PrepareValuesForAtoOElectricLevel(MemoryLayoutOrder layoutOrder)
{
SetCalculateAll(true);
CalculateYx = false;
SetQBufferSize(_plan.NTr * _plan.NRc);
PrepareLayoutOrder(layoutOrder, _plan.NxTotalLength, 2 * Ny, _plan.NTr, _plan.NRc);
}
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);
}
private void PrepareValuesForAtoOElectricSite(MemoryLayoutOrder layoutOrder)
{
SetCalculateAll(true);
CalculateYx = false;
SetQBufferSize(Nz);
PrepareLayoutOrder(layoutOrder, Nx, Ny, Nz, 1);
}
public GreenTensor CalculateSymmAtoA(ScalarSegments segments, MemoryLayoutOrder layoutOrder, bool mirrorPart)
{
if (segments == null)
{
throw new ArgumentNullException(nameof(segments));
}
_mirrorPart = mirrorPart;
SetSegments(segments);
_symmGreenTensor = AllocateNewSymm("xx", "yy", "zz", "xy");
SetGreenTensorAndRadii(_symmGreenTensor, segments.Radii);
if (_calcLength != 0)
{
if (!KnotsAreReady)
{
PrepareKnotsAtoA(segments.Radii, _nxStart, _calcLength);
}
PrepareValuesForSymmAtoA(layoutOrder);
RunAlongXElectric(_nxStart, _calcLength);
RunAlongYElectric(_nxStart, _calcLength);
}
return(_symmGreenTensor);
}
private void PrepareValuesForAsymAtoA(MemoryLayoutOrder layoutOrder)
{
SetCalculateAll(false);
CalculateXz = true;
CalculateYz = true;
SetQBufferSize(Nz * Nz);
PrepareLayoutOrder(layoutOrder, _nxTotalLength, 2 * Ny, Nz, Nz);
}
private void PerformFftGiem2g(GreenTensor gt, MemoryLayoutOrder layoutOrder)
{
if (layoutOrder != MemoryLayoutOrder.AlongVertical)
{
throw new InvalidOperationException($"{nameof(layoutOrder)} should be AlongVertical to perform fft");
}
Giem2gGreenTensor.CalcFFTofGreenTensor(gt);
}
private void PrepareValuesForSymmAtoA(MemoryLayoutOrder layoutOrder)
{
SetCalculateAll(false);
CalculateXx = true;
CalculateXy = true;
CalculateYy = true;
CalculateZz = true;
SetQBufferSize(Nz + Nz * (Nz - 1) / 2);
PrepareLayoutOrderSymm(layoutOrder, _nxTotalLength, 2 * Ny, Nz);
}
private void PopulateForFft(GreenTensor gt, MemoryLayoutOrder layoutOrder, int nxLength, bool symm = false)
{
if (Solver.IsParallel)
{
new GreenTensorFftPopulator(gt, Model, symm)
.PopulateForFftDistributedAlongX(layoutOrder, nxLength);
}
else
{
new GreenTensorFftPopulator(gt, Model, symm)
.PopulateForFft(layoutOrder);
}
}
private void PerformFftAsym(GreenTensor gt, MemoryLayoutOrder layoutOrder)
{
if (layoutOrder != MemoryLayoutOrder.AlongVertical)
{
throw new InvalidOperationException($"{nameof(layoutOrder)} should be AlongVertical to perform fft");
}
var nz = Model.Nz;
int sizeAsym = nz * nz;
MakeFftForComponent(gt, "xz", sizeAsym);
MakeFftForComponent(gt, "yz", sizeAsym);
}
private void PerformFftSymm(GreenTensor gt, MemoryLayoutOrder layoutOrder)
{
if (layoutOrder != MemoryLayoutOrder.AlongVertical)
{
throw new InvalidOperationException($"{nameof(layoutOrder)} should be AlongVertical to perform fft");
}
var nz = Model.Nz;
int sizeSymm = (nz * (nz + 1)) / 2;
MakeFftForComponent(gt, "xx", sizeSymm);
MakeFftForComponent(gt, "xy", sizeSymm);
MakeFftForComponent(gt, "yy", sizeSymm);
MakeFftForComponent(gt, "zz", sizeSymm);
}
private void PrepareLayoutOrder(MemoryLayoutOrder layoutOrder)
{
if (layoutOrder == MemoryLayoutOrder.AlongLateral)
{
_layoutStep = (int)(_nx * _ny * 4);
_layoutShiftFactor = 1;
}
else if (layoutOrder == MemoryLayoutOrder.AlongVertical)
{
_layoutStep = 1;
_layoutShiftFactor = _length;
}
else
{
throw new InvalidOperationException(nameof(layoutOrder));
}
}
protected void PrepareLayoutOrderSymm(MemoryLayoutOrder layoutOrder, int nx, int ny, int nz)
{
if (layoutOrder == MemoryLayoutOrder.AlongLateral)
{
_layoutStep = nx * ny;
_layoutShiftFactor = 1;
}
else if (layoutOrder == MemoryLayoutOrder.AlongVertical)
{
_layoutStep = 1;
_layoutShiftFactor = nz + nz * (nz - 1) / 2;
}
else
{
throw new InvalidOperationException(nameof(layoutOrder));
}
}
public static void Print(this ILogger logger, AnomalyCurrent ac, MemoryLayoutOrder layoutOrder, int k)
{
ac.LayoutOrder = layoutOrder;
var la = GetLayerAccessor(ac, k);
string result;
for (int i = 0; i < ac.Nx; i++)
{
result = $"[{i:000}] : ";
for (int j = 0; j < ac.Ny; j++)
{
var val = la[i, j];
result += $"{Math.Sign(val.Real) * val.Magnitude:E2} ";
}
logger.WriteStatus(result);
}
}
public void PopulateForFftDistributedAlongX(MemoryLayoutOrder layoutOrder, int nxLength)
{
PrepareLayoutOrder(layoutOrder);
if (_greenTensor.Has("XX"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["XX"], 1);
}
if (_greenTensor.Has("YY"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["YY"], 1);
}
if (_greenTensor.Has("ZZ"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["ZZ"], 1);
}
if (_greenTensor.Has("XY"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["XY"], -1);
}
if (_greenTensor.Has("XZ"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["XZ"], 1);
}
if (_greenTensor.Has("YZ"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["YZ"], -1);
}
if (_greenTensor.Has("ZX"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["ZX"], 1);
}
if (_greenTensor.Has("ZY"))
{
PopulateForFftDistributedAlongX(nxLength, _greenTensor["ZY"], -1);
}
}
public void PopulateForFft(MemoryLayoutOrder layoutOrder)
{
PrepareLayoutOrder(layoutOrder);
if (_greenTensor.Has("XX"))
{
PopulateForFft(_greenTensor["XX"], 1, 1);
}
if (_greenTensor.Has("YY"))
{
PopulateForFft(_greenTensor["YY"], 1, 1);
}
if (_greenTensor.Has("ZZ"))
{
PopulateForFft(_greenTensor["ZZ"], 1, 1);
}
if (_greenTensor.Has("XY"))
{
PopulateForFft(_greenTensor["XY"], -1, -1);
}
if (_greenTensor.Has("XZ"))
{
PopulateForFft(_greenTensor["XZ"], -1, 1);
}
if (_greenTensor.Has("YZ"))
{
PopulateForFft(_greenTensor["YZ"], 1, -1);
}
if (_greenTensor.Has("ZX"))
{
PopulateForFft(_greenTensor["ZX"], -1, 1);
}
if (_greenTensor.Has("ZY"))
{
PopulateForFft(_greenTensor["ZY"], 1, -1);
}
}
public GreenTensor CalculateAtoOMagnetic(ScalarSegments segments, ObservationSite site, MemoryLayoutOrder layoutOrder)
{
if (segments == null)
{
throw new ArgumentNullException(nameof(segments));
}
var greenTensor = AllocateNew("xx", "yx", "xy", "xz", "yz", "zx", "zy");
SetSegments(segments);
SetGreenTensorAndRadii(greenTensor, segments.Radii);
PrepareValuesForAtoOMagneticSite(layoutOrder);
PrepareKnotsAtoO(segments.Radii, site);
RunAlongXMagnetic(site);
RunAlongYMagnetic(site);
return(greenTensor);
}
