public ComplexVector CalculateAnomalyFieldE(ObservationSite site, AnomalyCurrent jQ)
{
var gt = CalculateGreenTensorAtoOSiteElectric(site);
var result = ConvolutorE(gt, jQ);
return(result);
}
public ComplexVector CalculateAnomalyFieldH(ObservationSite site, AnomalyCurrent jQ)
{
var gt = CalculateGreenTensorAtoOSiteMagnetic(site);
var result = CalculateH(gt, jQ);
return(result);
}
private void CalculateAnomalyField(AnomalyCurrent src, AnomalyCurrent dst, GreenTensor gt, bool electric)
{
var forward = src.Nz == 1 ? Pool.Plan3 : Pool.Plan3Nz;
var backward = dst.Nz == 1 ? Pool.Plan3 : Pool.Plan3Nz;
UNF.ClearBuffer(forward.Buffer1Ptr, forward.BufferLength);
PrepareForForwardFft(src, forward.Buffer1Ptr);
Pool.ExecuteForward(forward);
//Clear(backward.Input);
if (electric)
{
ApplyGreenTensorAlongZForE(gt, forward.Buffer1Ptr, backward.Buffer2Ptr);
}
else
{
ApplyGreenTensorAlongZForH(gt, forward.Buffer1Ptr, backward.Buffer2Ptr);
}
Pool.ExecuteBackward(backward);
var scalar = new Complex(1 / ((double)Model.Nx * (double)Model.Ny * 4), 0);
var len = backward.BufferLength;
Zscal(len, scalar, backward.Buffer2Ptr);
ExtractData(backward.Buffer2Ptr, dst);
}
public void CalculateAnomalyFieldE(ObservationLevel level, AnomalyCurrent jQ, AnomalyCurrent field)
{
if (_eGreenTensors.ContainsKey(level))
{
using (Solver.Profiler?.StartAuto(ProfilerEvent.AtoOFields))
{
CalculateAnomalyFieldE(jQ, field, _eGreenTensors[level]);
}
return;
}
var greenTensor = CalculateGreenTensorAtoOLevelElectric(level);
var arg = new GreenTensorCalculatedEventArgs(level, greenTensor);
OnGreenTensorECalculated(arg);
using (Solver.Profiler?.StartAuto(ProfilerEvent.AtoOFields))
{
CalculateAnomalyFieldE(jQ, field, greenTensor);
}
if (arg.SupressGreenTensorDisposal)
{
_eGreenTensors.Add(level, greenTensor);
}
else
{
greenTensor.Dispose();
}
}
public static void PrintZ(AnomalyCurrent ac, MemoryLayoutOrder layoutOrder, int k)
{
ac.LayoutOrder = layoutOrder;
Console.WriteLine("Z");
Print(ac, VerticalLayerAccessor.NewZ(ac, k));
}
private void RunSlavePart(AnomalyCurrent b, AnomalyCurrent x)
{
while (RecvCommandFromMaster() != Exit)
{
_operatorA.Apply(b, x);
}
}
public void Solve(ConvolutionOperator operatorA, AnomalyCurrent b, AnomalyCurrent x)
{
if (operatorA == null)
{
throw new ArgumentNullException(nameof(operatorA));
}
if (b == null)
{
throw new ArgumentNullException(nameof(b));
}
if (x == null)
{
throw new ArgumentNullException(nameof(x));
}
_operatorA = operatorA;
if (_solver.IsParallel && IsSlavePart)
{
RunSlavePart(b, x);
}
else
{
RunMainPart(b, x);
}
}
public void Apply(AnomalyCurrent input, AnomalyCurrent output)
{
if (_greenTensor == null)
{
throw new InvalidOperationException($"{nameof(_greenTensor)} is not set");
}
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
_input = input;
_output = output;
if (_solver.Engine != ForwardSolverEngine.Giem2g)
{
CalculateOperatorAorKr();
}
else
{
DoWithProfiling(ApplyGiem2gOperator, ProfilerEvent.OperatorGiem2gApply);
}
}
protected override void OnHFieldsAtLevelCalculated(ObservationLevel level,
AnomalyCurrent normalField, AnomalyCurrent anomalyField)
{
var e = new MtFieldsAtLevelCalculatedEventArgs(CurrentSource, level, normalField, anomalyField);
_hFields.Add(e);
HFieldsAtLevelCalculated?.Invoke(this, e);
}
public AnomalyCurrentAccessor(AnomalyCurrent ac, int comp)
{
_ptr = ac.Ptr;
_comp = comp;
_nx = ac.Nx;
_ny = ac.Ny;
_nz = ac.Nz;
}
public CieSolverFinishedEventArgs(AnomalyCurrent chi, GreenTensor gt)
{
if (chi == null)
{
throw new ArgumentNullException(nameof(chi));
}
Chi = chi;
Gt = gt;
}
public ConvolutionOperator(ForwardSolver solver)
: base(solver)
{
_solver = solver;
_rFunction = Alloc(Model.Anomaly.LocalSize.Nx * Model.Anomaly.LocalSize.Ny * Model.Nz);
_forwardFactors = Alloc(Model.Nz);
_backwardFactors = Alloc(Model.Nz);
_rx = AnomalyCurrent.AllocateNewLocalSize(solver.MemoryProvider, solver.Model);
}
public void Solve(AnomalyCurrent chiX, AnomalyCurrent chiY)
{
Logger.WriteStatus("Starting Cartesian MT Forward solver...");
Logger.WriteStatus("\n\nStarting Polarization X\n\n");
CurrentSource = Polarization.X;
CalculateOnObservationsForGivenChi(chiX);
Logger.WriteStatus("\n\nStarting Polarization Y\n\n");
CurrentSource = Polarization.Y;
CalculateOnObservationsForGivenChi(chiY);
}
public static void PrintAll(AnomalyCurrent ac, int k)
{
ac.LayoutOrder = MemoryLayoutOrder.AlongVertical;
Console.WriteLine("X");
Print(ac, VerticalLayerAccessor.NewX(ac, k));
Console.WriteLine("Y");
Print(ac, VerticalLayerAccessor.NewY(ac, k));
Console.WriteLine("Z");
Print(ac, VerticalLayerAccessor.NewZ(ac, k));
}
private static void Print(AnomalyCurrent ac, ILayerAccessor la)
{
for (int i = 0; i < ac.Nx; i++)
{
Console.Write($"[{i:000}] : ");
for (int j = 0; j < ac.Ny; j++)
{
var val = la[i, j];
Console.Write($"{Math.Sign(val.Real) * val.Magnitude:E2} ");
}
Console.WriteLine();
}
}
private void RunMainPart(AnomalyCurrent b, AnomalyCurrent x)
{
var rhs = new NativeVector(b.Ptr, _problemSize);
var result = new NativeVector(x.Ptr, _problemSize);
_numberOfMults = 0;
_numberOfDotProducts = 0;
_fgmres.Solve(rhs, result, result);
if (_solver.IsParallel)
{
SendCommand(Exit);
}
}
private void _solver_MatrixVectorMultRequest(object sender, MatrixVectorMultRequestEventArgs e)
{
using (_solver.Profiler?.StartAuto(ProfilerEvent.ApplyOperatorA))
{
if (_solver.IsParallel)
{
SendCommand(Mult);
}
var ls = Model.Anomaly.LocalSize;
var inp = AnomalyCurrent.ReUseMemory(e.X.Ptr, ls.Nx, ls.Ny, Model.Nz);
var res = AnomalyCurrent.ReUseMemory(e.Result.Ptr, ls.Nx, ls.Ny, Model.Nz);
_operatorA.Apply(inp, res);
_numberOfMults++;
}
}
private static void PrepareForForwardFft(AnomalyCurrent src, Complex *inputPtr)
{
int nx = src.Nx;
int ny = src.Ny;
int nz = src.Nz;
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
long shiftSrc = (i * ny + j) * 3 * nz;
long shiftDst = (i * ny * 2 + j) * 3 * nz;
Copy(3 * nz, src.Ptr + shiftSrc, inputPtr + shiftDst);
}
}
}
private static void ExtractData(Complex *outputFftPtr, AnomalyCurrent field)
{
int nx = field.Nx;
int ny = field.Ny;
int nz = field.Nz;
for (int i = 0; i < nx; i++)
{
for (int j = 0; j < ny; j++)
{
long shiftDst = (i * ny + j) * 3 * nz;
long shiftSrc = (i * ny * 2 + j) * 3 * nz;
//Copy(3 * nz, outputFft.Ptr + shiftSrc, field.Ptr + shiftDst);
Zaxpy(3 * nz, Complex.One, outputFftPtr + shiftSrc, field.Ptr + shiftDst);
}
}
}
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 FieldsAtLevelCalculatedEventArgs(ObservationLevel level, AnomalyCurrent normalField, AnomalyCurrent anomalyField)
{
if (level == null)
{
throw new ArgumentNullException(nameof(level));
}
if (normalField == null)
{
throw new ArgumentNullException(nameof(normalField));
}
if (anomalyField == null)
{
throw new ArgumentNullException(nameof(anomalyField));
}
Level = level;
NormalField = normalField;
AnomalyField = anomalyField;
Level = level;
}
protected override AnomalyCurrent CalculateNormalFieldH(ObservationLevel level)
{
var normalField = AnomalyCurrent.AllocateNewOneLayer(MemoryProvider, Model);
Clear(normalField);
var mtAdmitanceOnObs = PlaneWaveCalculator.CalculateFieldH(Model, level.Z);
if (CurrentSource == Polarization.X)
{
var la = GetLayerAccessorY(normalField, 0);
SetValue(la, mtAdmitanceOnObs);
}
if (CurrentSource == Polarization.Y)
{
var la = GetLayerAccessorX(normalField, 0);
SetValue(la, -mtAdmitanceOnObs);
}
return(normalField);
}
protected override void CalculateNormalFieldFromSource(AnomalyCurrent field)
{
Clear(field);
for (int k = 0; k < field.Nz; k++)
{
var mtField = CalculateEFieldForPlaneWaveOnAnomalies(Model, Model.Anomaly.Layers[k]);
var laS = CurrentSource == Polarization.X ?
GetLayerAccessorX(field, k) :
GetLayerAccessorY(field, k);
for (int i = 0; i < laS.Nx; i++)
{
for (int j = 0; j < laS.Ny; j++)
{
laS[i, j] = mtField;
}
}
}
_normalFieldAtAnomaly = field;
}
public static unsafe AnomalyCurrent GatherFromAllProcesses(ForwardSolver solver, AnomalyCurrent field)
{
if (!solver.IsParallel)
{
return(field);
}
int size = 3 * field.Nx * field.Ny;
if (solver.Mpi.IsMaster)
{
var result = AnomalyCurrent.AllocateNew(solver.MemoryProvider, solver.Model.Nx, solver.Model.Ny, 1);
solver.MpiRealPart.Gather(result.Ptr, field.Ptr, size, size);
return(result);
}
else
{
solver.MpiRealPart.Gather(null, field.Ptr, 0, size);
return(null);
}
}
private ComplexVector CalculateH(GreenTensor gt, AnomalyCurrent jQ)
{
throw new NotImplementedException();
}
protected void CalculateAnomalyFieldH(AnomalyCurrent src, AnomalyCurrent dst, GreenTensor greenTensor) => CalculateAnomalyField(src, dst, greenTensor, electric: false);
public static ILayerAccessor NewZ(AnomalyCurrent ac, int k) => new VerticalLayerAccessor(ac.Ptr + ac.Nz * 2, ac.Nx, ac.Ny, ac.Nz, k);
public static IAnomalyCurrentAccessor NewZ(AnomalyCurrent ac) => new AnomalyCurrentAccessor(ac, 2);
public static IAnomalyCurrentAccessor GetZ(this AnomalyCurrent ac) => AnomalyCurrentAccessor.NewZ(ac);
public void CalculateAnomalyFieldH(SourceLayer layer, ObservationLevel level, AnomalyCurrent src, AnomalyCurrent dst)
{
using (var greenTensor = CalculateGreenTensorMagnetic(layer, level))
CalculateAnomalyFieldH(src, dst, greenTensor);
}
