public AnomalyCurrentFgmresSolver(ForwardSolver solver)
{
if (solver == null)
{
throw new ArgumentNullException(nameof(solver));
}
_solver = solver;
_problemSize = Model.Anomaly.LocalSize.Nx * Model.Anomaly.LocalSize.Ny * Model.Nz * 3;
var settings = _solver.Settings;
var fgmresParams = new GmresParams(_problemSize, settings.OuterBufferLength)
{
Tolerance = settings.Residual,
MaxRepeatNumber = settings.MaxRepeatsNumber,
ResidualAtRestart = ResidualAtRestart.ComputeTheTrue,
InitialGuess = InitialGuess.UserSupplied,
GramSchmidtType = GramSchmidtType.IterativeClassical,
};
_fgmres = new FlexibleGmresWithGmresPreconditioner(_solver.Logger, _solver.MemoryProvider,
fgmresParams, settings.InnerBufferLength);
_fgmres.MatrixVectorMultRequest += _solver_MatrixVectorMultRequest;
_fgmres.DotProductRequest += _solver_DotProductRequest;
_fgmres.IterationComplete += solver_IterationComplete;
}
static void PrepareBkgAndAnomaly(ForwardSolver solver, ref giem2g_background bkg, ref giem2g_anomaly anomaly)
{
int nz = solver.Model.Nz;
int nx = solver.Model.Nx;
int ny = solver.Model.Ny;
var model = solver.Model;
var section = model.Section1D;
var n = section.NumberOfLayers;
int first = 0;
if (model.GetLayerDepth(0) < 0)
{
n = n - 1;
first = 1;
}
bkg.nl = n - 1;
var thick = solver.MemoryProvider.AllocateDouble(bkg.nl - 1);
var csigb = solver.MemoryProvider.AllocateComplex(bkg.nl + 1);
for (int i = 0; i < bkg.nl - 1; i++)
{
thick [i] = (double)section [i + 1 + first].Thickness;
}
for (int i = 0; i < bkg.nl + 1; i++)
{
csigb [i] = section [i + first].Zeta;
}
bkg.thickness = new IntPtr(thick);
bkg.csigb = new IntPtr(csigb);
var z = solver.MemoryProvider.AllocateDouble(nz + 1);
var dz = solver.MemoryProvider.AllocateDouble(nz);
for (int i = 0; i < nz; i++)
{
z [i] = (double)model.Anomaly.Layers [i].Depth;
dz [i] = (double)model.Anomaly.Layers [i].Thickness;
}
z [nz] = z [nz - 1] + dz [nz - 1];
anomaly.nz = nz;
// ATTENTION ! formal transpose in horizontal dimensions!!
anomaly.nx = ny;
anomaly.ny = nx;
anomaly.z = new IntPtr(z);
anomaly.dz = new IntPtr(dz);
anomaly.dx = (double)model.LateralDimensions.CellSizeX;
anomaly.dy = (double)model.LateralDimensions.CellSizeY;
}
// public static ForwardSolver current_solver;
public static GreenTensor CalcAtoATensor(ForwardSolver solver, GreenTensor gt)
{
var giem2g_ie_op = new giem2g_data();
var bkg = new giem2g_background();
var anomaly = new giem2g_anomaly();
GreenTensor gt_new;
// current_solver = solver;
PrepareBkgAndAnomaly(solver, ref bkg, ref anomaly);
//giem2g_set_logger(GIEM2G_LOGGER);
IntPtr ie_op_ptr;
if (gt == null || !gt.Has("giem2g"))
{
gt_new = PrepareGIEM2GTensor(solver, ref giem2g_ie_op, anomaly);
ie_op_ptr = giem2g_ie_op.giem2g_tensor;
}
else
{
ie_op_ptr = new IntPtr(gt ["giem2g"].Ptr);
gt_new = gt;
}
var omega = solver.Model.Omega;
giem2g_calc_ie_kernel(ie_op_ptr, bkg, anomaly, omega);
solver.MemoryProvider.Release((void *)bkg.csigb);
solver.MemoryProvider.Release((void *)bkg.thickness);
solver.MemoryProvider.Release((void *)anomaly.z);
solver.MemoryProvider.Release((void *)anomaly.dz);
return(gt_new);
}
static GreenTensor PrepareGIEM2GTensor(ForwardSolver solver, ref giem2g_data giem2g_ie_op, giem2g_anomaly anomaly)
{
int nz = solver.Model.Nz;
int nx = solver.Model.Nx;
int ny = solver.Model.Ny;
giem2g_ie_op.comm = solver.Mpi.CommunicatorC2Fortran();
giem2g_calc_data_sizes(anomaly, ref giem2g_ie_op);
var buff = FftBuffersPool.GetBuffer(solver.Model);
if (buff.Plan3Nz.BufferLength >= giem2g_ie_op.fft_buffers_length)
{
giem2g_ie_op.fft_buffer_in = buff.Plan3Nz.Buffer1Ptr;
giem2g_ie_op.fft_buffer_out = buff.Plan3Nz.Buffer2Ptr;
}
else
{
var len = giem2g_ie_op.fft_buffers_length;
giem2g_ie_op.fft_buffer_in = solver.MemoryProvider.AllocateComplex(len);
giem2g_ie_op.fft_buffer_out = solver.MemoryProvider.AllocateComplex(len);
solver.Logger.WriteError("Allocate additional memory for FFT inside GIEM2G!!");
}
var giem2g_ptrs = AllocateGiem2gDataBuffers(solver.MemoryProvider, ref giem2g_ie_op, nz);
giem2g_prepare_ie_kernel(anomaly, giem2g_ie_op);
var gt = GreenTensor.CreateGiem2gTensor(solver.MemoryProvider, nx, ny, nz, nz, giem2g_ptrs);
return(gt);
}
public override void Init()
{
Evaluator = new ForwardEvaluator(nodeFactory);
Solver = new ForwardSolver(nodeFactory, this);
WorkerState = Solver.Init(Command);
}
public override void Init()
{
Evaluator = new ForwardEvaluator();
Solver = new ForwardSolver()
{
Worker = this
};
WorkerCommandResult = Solver.Init(Command);
}
