private static double[] CalculateLambdasForLog10(HankelCoefficients hankel, double[] rho)
{
var rhoLength = rho.Length;
var k = new double[hankel.GetLengthOfLambdaWithRespectTo(rhoLength)];
var rhoMin = rho[0];
var rhoStep = hankel.GetLog10RhoStep();
int n1 = hankel.GetN1WithRespectTo(rhoLength);
int n2 = hankel.GetN2WithRespectTo(rhoLength);
k[-n1] = 1 / rhoMin;
for (int i = -n1 + 1; i <= n2 - n1; i++)
{
k[i] = k[i - 1] / rhoStep;
}
for (int i = -n1 - 1; i >= 0; i--)
{
k[i] = k[i + 1] * rhoStep;
}
return(k);
}
public ScalarPlansCreater(LateralDimensions lateral, HankelCoefficients hankel, int numberOfHankels)
{
_lateral = lateral;
_hankel = hankel;
_numberOfHankels = Math.Abs(numberOfHankels);
}
public void AddNewLog10PlanItem(HankelCoefficients hankelCoefficients, double[] rho)
{
if (hankelCoefficients == null)
{
throw new ArgumentNullException(nameof(hankelCoefficients));
}
if (rho == null)
{
throw new ArgumentNullException(nameof(rho));
}
var lambdas = CalculateLambdasForLog10(hankelCoefficients, rho);
_items.Add(new ScalarPlanItem(this, hankelCoefficients, rho, lambdas));
}
public AtoAGreenTensorCalculatorComponent(ForwardSolver solver) : base(solver)
{
if (Solver.Engine == ForwardSolverEngine.Giem2g)
{
if (!Solver.IsParallel)
{
throw new NotImplementedException("GIEM2G works only in parallel mode!");
}
_plan = null;
_scalarCalc = null;
_tensorCalc = null;
_mirroringX = false;
_realCalcNxStart = -1;
_totalNxLength = -1;
_calcNxLength = -1;
return;
}
_plan = new ScalarPlansCreater(Model.LateralDimensions, HankelCoefficients.LoadN40(), Solver.Settings.NumberOfHankels)
.CreateForAnomalyToAnomaly();
_scalarCalc = GreenScalarCalculator.NewAtoACalculator(Logger, Model);
_tensorCalc = new AtoAGreenTensorCalculator(Logger, Model, MemoryProvider);
if (Solver.IsParallel)
{
var localNxStart = Mpi.CalcLocalNxStart(Model.LateralDimensions);
_totalNxLength = Mpi.CalcLocalNxLength(Model.LateralDimensions);
_mirroringX = localNxStart >= Model.Nx;
_realCalcNxStart = _mirroringX ? 2 * Model.Nx - localNxStart - _totalNxLength + 1 : localNxStart;
_calcNxLength = _totalNxLength;
if (_realCalcNxStart + _totalNxLength == Model.Nx + 1)
{
_calcNxLength--;
}
}
else
{
_mirroringX = false;
_realCalcNxStart = 0;
_totalNxLength = 2 * Model.Nx;
_calcNxLength = Model.Nx;
}
}
private static void AddLog10Plans(ScalarPlan plan, HankelCoefficients hankel, double rhoMin, double rhoMax, double rhoStep, int n)
{
var rho1 = CreateRhoFromMin(rhoMin, rhoMax, rhoStep);
var r2 = rho1[rho1.Length - 1];
var r1 = rho1[rho1.Length - 2];
var step = (r2 - r1) / n;
plan.AddNewLog10PlanItem(hankel, rho1);
for (int i = 1; i < n; i++)
{
var rhoN = CreateRhoFromMax(rhoMin, r2 - i * step, rhoStep);
plan.AddNewLog10PlanItem(hankel, rhoN);
}
}
public ScalarPlanItem(ScalarPlan parent, HankelCoefficients hankelCoefficients, double[] rho, double[] lambdas)
{
if (parent == null)
{
throw new ArgumentNullException(nameof(parent));
}
if (hankelCoefficients == null)
{
throw new ArgumentNullException(nameof(hankelCoefficients));
}
if (rho == null)
{
throw new ArgumentNullException(nameof(rho));
}
if (lambdas == null)
{
throw new ArgumentNullException(nameof(lambdas));
}
_parent = parent;
Lambdas = lambdas;
HankelCoefficients = hankelCoefficients;
Rho = rho;
}
public StoOCalculator(ForwardSolver solver) : base(solver)
{
_templateTensorPlan = DistibutedUtils.CreateTensorPlanAtoO(Mpi, Model, 1, 1);
_gtc = new AtoOLevelGreenTensorCalculator(Logger, Model, MemoryProvider);
_plansCreater = new ScalarPlansCreater(Model.LateralDimensions, HankelCoefficients.LoadN40(), Solver.Settings.NumberOfHankels);
}
