private ScalarSegments CalculateParallelScalars(ScalarPlan plan, Transceiver[] transceivers)
{
var pm = new ParallelManager <Transceiver>(Mpi).WithTasks(transceivers);
GreenScalars gs = null;
ScalarSegments localSegments = null;
pm.Run(tasks =>
{
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoACalc))
{
gs = _scalarCalc.Calculate(plan, tasks, Profiler);
}
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoASegments))
{
localSegments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, gs);
}
});
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoACommunicate))
{
var allSegments1 = ScalarSegments.AllocateScalarSegments(MemoryProvider, plan, gs, transceivers.Length);
var allSegments2 = ScalarSegments.AllocateScalarSegments(MemoryProvider, plan, gs, transceivers.Length);
DistributeSegments(plan, pm, gs, localSegments, allSegments1, allSegments2);
localSegments.Dispose();
allSegments1.Dispose();
return(allSegments2);
}
}
public GreenTensor CalculateSymmAtoA(ScalarSegments segments, MemoryLayoutOrder layoutOrder, bool mirrorPart)
{
if (segments == null)
{
throw new ArgumentNullException(nameof(segments));
}
_mirrorPart = mirrorPart;
SetSegments(segments);
_symmGreenTensor = AllocateNewSymm("xx", "yy", "zz", "xy");
SetGreenTensorAndRadii(_symmGreenTensor, segments.Radii);
if (_calcLength != 0)
{
if (!KnotsAreReady)
{
PrepareKnotsAtoA(segments.Radii, _nxStart, _calcLength);
}
PrepareValuesForSymmAtoA(layoutOrder);
RunAlongXElectric(_nxStart, _calcLength);
RunAlongYElectric(_nxStart, _calcLength);
}
return(_symmGreenTensor);
}
public GreenTensor CalculateAtoOMagnetic(ScalarSegments segments, MemoryLayoutOrder layoutOrder, TensorPlan plan)
{
if (segments == null)
{
throw new ArgumentNullException(nameof(segments));
}
_plan = plan;
_useLocalTransofrmForI = _plan.NxTotalLength == 2 * Model.Nx;
var greenTensor = AllocateNew("xx", "yx", "xy", "xz", "yz", "zx", "zy");
SetSegments(segments);
SetGreenTensorAndRadii(greenTensor, segments.Radii);
if (_plan.NxCalcLength != 0)
{
PrepareValuesForAtoOMagneticLevel(layoutOrder);
PrepareKnotsAtoO(segments.Radii, _plan.NxStart, _plan.NxCalcLength);
RunAlongXMagnetic(_plan.NxStart, _plan.NxCalcLength);
RunAlongYMagnetic(_plan.NxStart, _plan.NxCalcLength);
}
return(greenTensor);
}
private ScalarSegments CalculateLocalScalars(ScalarPlan plan, Transceiver[] transceivers)
{
GreenScalars gs;
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoACalc))
{
gs = _scalarCalc.Calculate(plan, transceivers, Profiler);
}
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoASegments))
{
var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, gs);
return(segments);
}
}
private GreenTensor CalculateGreenTensorAtoOSiteElectric(ObservationSite site)
{
var plan = _plansCreater.CreateForAnomalyToObservationSites(site);
var transceiver = TranceiverUtils.CreateAnomalyToObservation(Model.Anomaly, site);
var scalarCalculator = GreenScalarCalculator.NewAtoOElectricCalculator(Logger, Model);
var scalars = scalarCalculator.Calculate(plan, transceiver);
var calc = new AtoOSiteGreenTensorCalculator(Logger, Model, MemoryProvider);
var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, scalars);
var gt = calc.CalculateAtoOElectric(segments, site, MemoryLayoutOrder.AlongLateral);
segments.Dispose();
return(gt);
}
private GreenTensor CalculateGreenTensorElectric(SourceLayer layer, ObservationLevel level)
{
var plan = _plansCreater.CreateForSourceToObservation(layer, level);
var transceiver = TranceiverUtils.CreateSourceToObservations(SourceThickness, layer, level);
var scalarCalculator = GreenScalarCalculator.NewAtoOElectricCalculator(Logger, Model);
var scalars = scalarCalculator.Calculate(plan, transceiver);
using (var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, scalars))
{
var tensorPlan = new TensorPlan(_templateTensorPlan, layer, level);
_gtc.ResetKnots();
var gt = _gtc.CalculateAtoOElectric(segments, MemoryLayoutOrder.AlongVertical, tensorPlan);
PerformGreenTensorFft(gt);
return(gt);
}
}
private unsafe GreenTensor CalculateGreenTensorAtoOLevelElectric(ObservationLevel level)
{
using (Solver.Profiler?.StartAuto(ProfilerEvent.AtoOGreenCalc))
{
var plan = _plansCreater.CreateForAnomalyToObservationLevels(level);
var transceiver = TranceiverUtils.CreateAnomalyToObservation(Model.Anomaly, level);
var scalarCalculator = GreenScalarCalculator.NewAtoOElectricCalculator(Logger, Model);
var scalars = scalarCalculator.Calculate(plan, transceiver);
using (var segments = ScalarSegments.AllocateAndConvert(MemoryProvider, plan, scalars))
{
var tensorPlan = new TensorPlan(_templateTensorPlan, level);
_gtc.ResetKnots();
var gt = _gtc.CalculateAtoOElectric(segments, MemoryLayoutOrder.AlongVertical, tensorPlan);
PerformGreenTensorFft(gt);
return(gt);
}
}
}
public GreenTensor CalculateAtoOMagnetic(ScalarSegments segments, ObservationSite site, MemoryLayoutOrder layoutOrder)
{
if (segments == null)
{
throw new ArgumentNullException(nameof(segments));
}
var greenTensor = AllocateNew("xx", "yx", "xy", "xz", "yz", "zx", "zy");
SetSegments(segments);
SetGreenTensorAndRadii(greenTensor, segments.Radii);
PrepareValuesForAtoOMagneticSite(layoutOrder);
PrepareKnotsAtoO(segments.Radii, site);
RunAlongXMagnetic(site);
RunAlongYMagnetic(site);
return(greenTensor);
}
protected void SetSegments(ScalarSegments segments)
{
_segments = segments;
}
private void DistributeSegments(ScalarPlan plan, ParallelManager <Transceiver> pm, GreenScalars gs, ScalarSegments local, ScalarSegments all, ScalarSegments result)
{
var starts = pm.GetAllStartIndecies();
var lengths = pm.GetAllLength();
var fullStarts = new int[lengths.Length];
var fullLength = new int[lengths.Length];
var localLength = gs.SingleScalars.Length;
int nComp = gs.GetNumberOfAvailableIs(plan);
int nRho = local.Radii.Length - 1;
var localSize = localLength * nComp * 2 * nRho;
for (int i = 0; i < starts.Length; i++)
{
fullStarts[i] = starts[i] * nComp * 2 * nRho;
fullLength[i] = lengths[i] * nComp * 2 * nRho;
}
Mpi.AllGatherV(local.Ptr, localSize, all.Ptr, fullLength, fullStarts);
using (Profiler?.StartAuto(ProfilerEvent.GreenScalarAtoATrans))
{
for (int i = 0; i < starts.Length; i++)
{
int start = starts[i];
int length = lengths[i];
var tmp = ScalarSegments.ReUseScalarSegments(all.Ptr + fullStarts[i], plan, gs, length);
for (int j = 0; j < result.SingleSegment.Length; j++)
{
var src = tmp.SingleSegment[j];
var dst = result.SingleSegment[j];
if (src.I1A != null)
{
for (int k = 0; k < length; k++)
{
dst.I1A[k + start] = src.I1A[k];
}
}
if (src.I2A != null)
{
for (int k = 0; k < length; k++)
{
dst.I2A[k + start] = src.I2A[k];
}
}
if (src.I3A != null)
{
for (int k = 0; k < length; k++)
{
dst.I3A[k + start] = src.I3A[k];
}
}
if (src.I4A != null)
{
for (int k = 0; k < length; k++)
{
dst.I4A[k + start] = src.I4A[k];
}
}
if (src.I5A != null)
{
for (int k = 0; k < length; k++)
{
dst.I5A[k + start] = src.I5A[k];
}
}
if (src.I1B != null)
{
for (int k = 0; k < length; k++)
{
dst.I1B[k + start] = src.I1B[k];
}
}
if (src.I2B != null)
{
for (int k = 0; k < length; k++)
{
dst.I2B[k + start] = src.I2B[k];
}
}
if (src.I3B != null)
{
for (int k = 0; k < length; k++)
{
dst.I3B[k + start] = src.I3B[k];
}
}
if (src.I4B != null)
{
for (int k = 0; k < length; k++)
{
dst.I4B[k + start] = src.I4B[k];
}
}
if (src.I5B != null)
{
for (int k = 0; k < length; k++)
{
dst.I5B[k + start] = src.I5B[k];
}
}
}
}
}
}
