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();
}
}
private AnomalyCurrent CalculateAnomalyFieldE(ObservationLevel level, AnomalyCurrent jQ)
{
var field = AnomalyCurrent.AllocateNewOneLayer(MemoryProvider, Model);
Clear(field);
_aToOCalculator.CalculateAnomalyFieldE(level, jQ, field);
return(field);
}
private static XElement ToXElement(ObservationLevel level)
{
return(new XElement(ObservationLevel,
new XAttribute(ObservationLevelNameAttr, level.Name),
new XAttribute(ObservationLevelXShiftAttr, level.ShiftAlongX),
new XAttribute(ObservationLevelYShiftAttr, level.ShiftAlongY),
new XAttribute(ObservationLevelZCoordinateAttr, level.Z)));
}
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 TensorPlan(TensorPlan plan, ObservationLevel level)
{
NxStart = plan.NxStart;
NxCalcLength = plan.NxCalcLength;
NxTotalLength = plan.NxTotalLength;
NRc = plan.NRc;
NTr = plan.NTr;
ShiftX = level.ShiftAlongX;
ShiftY = level.ShiftAlongY;
}
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);
}
}
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;
}
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);
}
}
}
private AllFieldsAtLevel GatherAllFieldsAtLevelLocally(ObservationLevel level, List <MtFieldsAtLevelCalculatedEventArgs> eFields, List <MtFieldsAtLevelCalculatedEventArgs> hFields)
{
var e1 = eFields.First(e => e.Level == level && e.Polarization == Polarization.X);
var e2 = eFields.First(e => e.Level == level && e.Polarization == Polarization.Y);
var h1 = hFields.First(h => h.Level == level && h.Polarization == Polarization.X);
var h2 = hFields.First(h => h.Level == level && h.Polarization == Polarization.Y);
return(new AllFieldsAtLevel(level)
{
AnomalyE1 = e1.AnomalyField,
NormalE1 = e1.NormalField,
AnomalyE2 = e2.AnomalyField,
NormalE2 = e2.NormalField,
AnomalyH1 = h1.AnomalyField,
NormalH1 = h1.NormalField,
AnomalyH2 = h2.AnomalyField,
NormalH2 = h2.NormalField,
});
}
private AllFieldsAtLevel GatherAllFieldsAtLevel(ObservationLevel level, List <MtFieldsAtLevelCalculatedEventArgs> eFields, List <MtFieldsAtLevelCalculatedEventArgs> hFields)
{
var e1 = eFields.First(e => e.Level == level && e.Polarization == Polarization.X);
var e2 = eFields.First(e => e.Level == level && e.Polarization == Polarization.Y);
var h1 = hFields.First(h => h.Level == level && h.Polarization == Polarization.X);
var h2 = hFields.First(h => h.Level == level && h.Polarization == Polarization.Y);
return(new AllFieldsAtLevel(level)
{
AnomalyE1 = DistibutedUtils.GatherFromAllProcesses(this, e1.AnomalyField),
NormalE1 = DistibutedUtils.GatherFromAllProcesses(this, e1.NormalField),
AnomalyE2 = DistibutedUtils.GatherFromAllProcesses(this, e2.AnomalyField),
NormalE2 = DistibutedUtils.GatherFromAllProcesses(this, e2.NormalField),
AnomalyH1 = DistibutedUtils.GatherFromAllProcesses(this, h1.AnomalyField),
NormalH1 = DistibutedUtils.GatherFromAllProcesses(this, h1.NormalField),
AnomalyH2 = DistibutedUtils.GatherFromAllProcesses(this, h2.AnomalyField),
NormalH2 = DistibutedUtils.GatherFromAllProcesses(this, h2.NormalField),
});
}
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 virtual void OnHFieldsAtLevelCalculated(ObservationLevel level,
AnomalyCurrent normalField, AnomalyCurrent anomalyField)
{
}
public void CalculateAnomalyFieldH(SourceLayer layer, ObservationLevel level, AnomalyCurrent src, AnomalyCurrent dst)
{
using (var greenTensor = CalculateGreenTensorMagnetic(layer, level))
CalculateAnomalyFieldH(src, dst, greenTensor);
}
protected abstract AnomalyCurrent CalculateNormalFieldH(ObservationLevel level);
public AllFieldsAtLevel(ObservationLevel level)
{
Level = level;
}
public MtFieldsAtLevelCalculatedEventArgs(Polarization polarization, ObservationLevel level, AnomalyCurrent normalField, AnomalyCurrent anomalyField)
: base(level, normalField, anomalyField)
{
Polarization = polarization;
}
public GreenTensorCalculatedEventArgs(ObservationLevel level, GreenTensor greenTensor)
{
Level = level;
GreenTensor = greenTensor;
}
