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); }
private void PopulateGreenAlongY(Complex *ptr, int ySym, long srcJ, long dstJ) { long shift = _layoutShiftFactor * srcJ; long shiftYSym = _layoutShiftFactor * dstJ; UNM.Zaxpy(_length, ySym, ptr + shift, _layoutStep, ptr + shiftYSym, _layoutStep); }
private void PopulateGreenAlongX(Complex *ptr, int xSym, long srcI, long dstI) { long shift = _layoutShiftFactor * (srcI * _ny2); long shiftXSym = _layoutShiftFactor * (dstI * _ny2); UNM.Zaxpy(_length, xSym, ptr + shift, _layoutStep, ptr + shiftXSym, _layoutStep); }
private void ApplyGreenTensorAlongZ() { var input = Pool.Plan3Nz.Buffer1Ptr; var result = Pool.Plan3Nz.Buffer2Ptr; int nz = Model.Nz; long asymNz = nz * nz; long symmNz = nz + nz * (nz - 1) / 2; int length = Pool.Plan3Nz.BufferLength / (3 * nz); var xx = _greenTensor["xx"].Ptr; var xy = _greenTensor["xy"].Ptr; var xz = _greenTensor["xz"].Ptr; var yy = _greenTensor["yy"].Ptr; var yz = _greenTensor["yz"].Ptr; var zz = _greenTensor["zz"].Ptr; Iterate(length, i => { //for (int i = 0; i < length; i++) // { long dataShift = i * 3L * nz; long symmShift = i * symmNz; long asymShift = i * asymNz; var dstX = result + dataShift; var dstY = result + dataShift + nz; var dstZ = result + dataShift + nz + nz; var srcX = input + dataShift; var srcY = input + dataShift + nz; var srcZ = input + dataShift + nz + nz; var one = Complex.One; var minusOne = -Complex.One; var zero = Complex.Zero; UNM.ZgemvSym(nz, &one, &zero, xx + symmShift, srcX, dstX); UNM.ZgemvSym(nz, &one, &one, xy + symmShift, srcY, dstX); UNM.ZgemvAsymNoTrans(nz, &one, &one, xz + asymShift, srcZ, dstX); UNM.ZgemvSym(nz, &one, &zero, xy + symmShift, srcX, dstY); UNM.ZgemvSym(nz, &one, &one, yy + symmShift, srcY, dstY); UNM.ZgemvAsymNoTrans(nz, &one, &one, yz + asymShift, srcZ, dstY); UNM.ZgemvAsymTrans(nz, &minusOne, &zero, xz + asymShift, srcX, dstZ); UNM.ZgemvAsymTrans(nz, &minusOne, &one, yz + asymShift, srcY, dstZ); UNM.ZgemvSym(nz, &one, &one, zz + symmShift, srcZ, dstZ); // } }); }
private void PopulateGreen(Complex *ptr, int xSym, int ySym, int i, int j) { long shift = _layoutShiftFactor * (i * _ny2 + j); long shiftXSym = _layoutShiftFactor * ((_nx2 - i) * _ny2 + j); long shiftYSym = _layoutShiftFactor * (i * _ny2 + _ny2 - j); long shiftXYSym = _layoutShiftFactor * ((_nx2 - i) * _ny2 + _ny2 - j); var src = ptr + shift; UNM.Zaxpy(_length, xSym, src, _layoutStep, ptr + shiftXSym, _layoutStep); UNM.Zaxpy(_length, ySym, src, _layoutStep, ptr + shiftYSym, _layoutStep); UNM.Zaxpy(_length, xSym * ySym, src, _layoutStep, ptr + shiftXYSym, _layoutStep); }
private void PerformLastStep() { var length = 3L * _output.Nz * _output.Nx * _output.Ny; if (_operatorType == OperatorType.A) { UNM.SubtractElementwise(length, _input.Ptr, _output.Ptr, _output.Ptr); UNM.SubtractElementwise(length, _output.Ptr, _rx.Ptr, _output.Ptr); } if (_operatorType == OperatorType.Chi0) { UNM.AddElementwise(length, _output.Ptr, _rx.Ptr, _output.Ptr); } }
private void ApplyOperatorR() { int length = _rx.Nx * _rx.Ny; int nz = _rx.Nz; Iterate(length, i => //for (int i = 0; i < length; i++) { long inz = i * nz; long inz3 = i * nz * 3; UNM.MultiplyElementwise(nz, _rFunction + inz, _input.Ptr + inz3, _rx.Ptr + inz3); UNM.MultiplyElementwise(nz, _rFunction + inz, _input.Ptr + inz3 + nz, _rx.Ptr + inz3 + nz); UNM.MultiplyElementwise(nz, _rFunction + inz, _input.Ptr + inz3 + nz + nz, _rx.Ptr + inz3 + nz + nz); //} }); }
private void ExtractData() { int nx = _output.Nx; int ny = _output.Ny; int nz = Model.Nz; var output = Pool.Plan3Nz.Buffer2Ptr; Iterate(nx, i => //for (int i = 0; i < nx; i++) { for (int j = 0; j < ny; j++) { long shiftDst = (i * ny + j) * 3L * nz; long shiftSrc = (i * ny * 2 + j) * 3L * nz; UNM.MultiplyElementwise(nz, _backwardFactors, output + shiftSrc, _output.Ptr + shiftDst); UNM.MultiplyElementwise(nz, _backwardFactors, output + shiftSrc + nz, _output.Ptr + shiftDst + nz); UNM.MultiplyElementwise(nz, _backwardFactors, output + shiftSrc + nz + nz, _output.Ptr + shiftDst + nz + nz); } }); }
public static GreenTensor AllocateNew(INativeMemoryProvider memoryProvider, int nx, int ny, int nTr, int nRc, long compSize, params string[] components) { var gt = new GreenTensor(memoryProvider, nx, ny, nTr, nRc); var fullSize = compSize * components.Length; var ptr = memoryProvider.AllocateComplex(fullSize); UNM.ClearBuffer(ptr, fullSize); var dict = new Dictionary <string, Component>(); for (int i = 0; i < components.Length; i++) { var nextPtr = ptr + i * compSize; dict.Add(components[i], new Component(gt, nextPtr)); } gt._basePtrs.Add(new IntPtr(ptr)); gt._components = dict; return(gt); }
private void PrepareForForwardFft() { var inputPtr = Pool.Plan3Nz.Buffer1Ptr; UNM.ClearBuffer(inputPtr, Pool.Plan3Nz.BufferLength); int nx = _rx.Nx; int ny = _rx.Ny; int nz = Model.Nz; Iterate(nx, i => //for (int i = 0; i < nx; i++) { for (int j = 0; j < ny; j++) { long shiftSrc = (i * ny + j) * 3L * nz; long shiftDst = (i * ny * 2 + j) * 3L * nz; UNM.MultiplyElementwise(nz, _forwardFactors, _rx.Ptr + shiftSrc, inputPtr + shiftDst); UNM.MultiplyElementwise(nz, _forwardFactors, _rx.Ptr + shiftSrc + nz, inputPtr + shiftDst + nz); UNM.MultiplyElementwise(nz, _forwardFactors, _rx.Ptr + shiftSrc + nz + nz, inputPtr + shiftDst + nz + nz); } }); }
private void Zscal(long length, Complex alpha, Complex *ptr) => UNF.Zscal(length, alpha, ptr);
protected static void Copy(long length, Complex *ptr, Complex *complexPtr) => UNF.Zcopy(length, ptr, complexPtr);
private static void Zaxpy(long n, Complex alpha, Complex *x, Complex *y) => UNF.Zaxpy(n, alpha, x, y);
private static void Zgemv(int n, int m, Complex a, Complex b, Complex *gt, Complex *src, Complex *dst) { UNF.ZgemvAtoO(n, m, &a, &b, gt, src, dst); }
private void FillQ(Complex *src, Complex[] dst, Complex alpha) { fixed(Complex *dstPtr = &dst[0]) UNM.Zaxpy(dst.Length, alpha, src, dstPtr); }
private void FillGreen(Complex[] buff, GreenTensor.Component ca, int sign, long shift, int step) { fixed(Complex *q = &buff[0]) UNM.Zaxpy(buff.Length, sign, q, ca.Ptr + shift, step); }