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