public override void CalculateTransmissionLoss(Platform platform, Mode mode, Radial radial, BottomProfile bottomProfile, SedimentType sedimentType, double windSpeed, IList<Tuple<double, SoundSpeedProfile>> soundSpeedProfilesAlongRadial) { var sourceDepth = platform.Depth; var frequency = (float)Math.Sqrt(mode.HighFrequency * mode.LowFrequency); if (mode.Depth.HasValue) sourceDepth += mode.Depth.Value; var directoryPath = Path.GetDirectoryName(radial.BasePath); if (directoryPath == null) throw new NullReferenceException("radial.BasePath does not point to a valid directory"); if (!Directory.Exists(directoryPath)) Directory.CreateDirectory(directoryPath); // Derived Parameters // ================== // Note: All the specific calculations given in the comments below assume a frequency of 1kHz // lambda is wavelength, in meters var lambda = ReferenceSoundSpeed / frequency; // if dz < 1m round dz down to either [1/10, 1/5, 1/4 or 1/2] m ... or multiples of 10^-n of these numbers // = [1 2 2.5 or 5 ] x 0.1m " " ... // if dz > 1m round dz down to either [1 2 2.5 5 ] m ... or multiples of 10^+n of these numbers // var fixpoints = new List<double> { 1, 2, 2.5, 5 }; // dz = 0.1 * lambda var dz = RelativeDepthResolution * lambda; // make dz a 'pretty' number //dz = Fix2X10pN(dz, fixpoints); // ndz is the depth decimation factor // MinimumOutputDepthResolution is 10m // dz is 0.1 * lambda (dz = 0.15 for a 1 kHz signal, 'pretty' dz = 0.2 @ 1kHz) // so ndz = (10 / 0.2) = 50 @ 1kHz // this means that we will only output every 50 computational depth cells, giving us a depth // resolution of 50 * 0.2m = 10m @ 1kHz which is what we want it to be. Outstanding. var ndz = (int)Math.Max(1.0, Math.Floor(MinimumOutputDepthResolution / dz)); // similar for dr and assoc. grid decimation // RelativeRangeResolution is 2, so with our 'pretty' dz = 0.2, dr = 0.4 var dr = RelativeRangeResolution * dz; // make dr a 'pretty' number, in this case 0.25 //dr = Fix2X10pN(dr, fixpoints); // ndr is the range decimation factor // MinimumOutputRangeResolution is 10m // dr is 0.25 * lambda, so (10 / 0.25) gives us an ndr of 40 // this means that we will only output every 40 computational range cells, giving us a range // resolution of 40 * 0.25m = 10m @ 1kHz which is what we want it to be. Outstanding. var ndr = (int)Math.Max(1, Math.Floor(MinimumOutputRangeResolution / dr)); // attenuation layer (round up to nearest dz) var sedimentLambda = sedimentType.CompressionWaveSpeed / frequency; var sedimentLayerDz = Math.Ceiling(LastLayerThickness * sedimentLambda / dz) * dz; var attenuationLayerDz = Math.Ceiling(AttenuationLayerThickness * sedimentLambda / dz) * dz; var maxSubstrateDepth = bottomProfile.MaxDepth + sedimentLayerDz; var zstep = dz * ndz; var zmplt = Math.Ceiling((bottomProfile.MaxDepth + 2 * zstep) / zstep) * zstep; // Maximum Depth for PE calc -> zmax // zmax is the z-limit for the PE calc from top of the water column to the bottom of the last substrate layer // (including the attentuation layer if, as recommended, this is included) var zmax = maxSubstrateDepth + attenuationLayerDz; var envFileName = radial.BasePath + ".env"; //Debug.WriteLine("Scenario: '{0}' Mode: '{2}' Analysis point: {1} Bearing: {3}, zmplt: {4}", // radial.TransmissionLoss.AnalysisPoint.Scenario.Name, // radial.TransmissionLoss.AnalysisPoint.Geo, // radial.TransmissionLoss.Modes[0].ModeName, // radial.Bearing, zmplt); using (var envFile = new StreamWriter(envFileName, false)) { envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "Scenario: '{0}' Mode: '{2}' Analysis point: {1} Bearing: {3}", radial.TransmissionLoss.AnalysisPoint.Scenario.Name, radial.TransmissionLoss.AnalysisPoint.Geo, radial.TransmissionLoss.Modes[0].ModeName, radial.Bearing)); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.000000}\t{1:0.000000}\t{2:0.000000}\t\tf [Frequency (Hz)], zs [Source Depth (m)], zrec0 [First receiever depth (m)]", frequency, sourceDepth, 0.1)); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.000000}\t{1:0.000000}\t{2}\t\t\trmax[Max range (m)], dr [Range resolution (m)], ndr [Range grid decimation factor]", mode.MaxPropagationRadius + (dr * ndr), dr, ndr)); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.000000}\t{1:0.000000}\t{2}\t{3:0.000000}\tzmax [Max computational depth (m)], dz [Depth resolution (m)], ndz [Depth grid decimation factor], zmplot [Maximum depth to plot (m)]", zmax, dz, ndz, zmplt)); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.000000}\t{1}\t{2}\t{3:0.000000}\t\tc0 [Reference sound speed (m/s)], np [Number of terms in Padé expansion], ns [Number of stability constraints], rs [Maximum range of stability constraints (m)]", ReferenceSoundSpeed, PadeExpansionTerms, StabilityConstraints, StabilityConstraintMaxRange)); // todo: different stuff goes here for RAMSGeo // bathymetry data var first = true; foreach (var profilePoint in bottomProfile.Profile) { envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.000000}\t{1:0.000000}{2}", profilePoint.Range * 1000, profilePoint.Depth, first ? "\t\t\t\t\tbathymetry data [range (m), depth (m)]" : "")); first = false; } envFile.WriteLine("-1\t-1"); // range-dependent environment profiles var firstRangeProfile = true; foreach (var rangeProfileTuple in soundSpeedProfilesAlongRadial) { // Range of profile only written for second and subsequent profiles if (!firstRangeProfile) envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.#}\t\t\t\t\t\t\tProfile range (m)", rangeProfileTuple.Item1 * 1000)); var firstSoundSpeedProfile = true; foreach (var profilePoint in rangeProfileTuple.Item2.Data) { if (double.IsNaN(profilePoint.SoundSpeed)) break; envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.######}\t{1:0.######}{2}", profilePoint.Depth, profilePoint.SoundSpeed, firstSoundSpeedProfile ? "\t\t\t\t\tsound speed profile in water [depth (m), sound speed (m/s)]" : "")); firstSoundSpeedProfile = false; } envFile.WriteLine("-1\t-1"); // todo: RAMGeo and RAMSGeo also support sediment layers, as well as range-dependent sediment, neither of which is not yet supported by ESME // If sediment layers are ever supported, put a loop like for the sound speed profile above // A sediment layer is analogous to a sound speed profile point // For range-dependent sediment, the sediment samples have to be at the same ranges as the sound speed profiles // so we might want to change the API to include sediment properties in what is the current range and sound speed profile tuple envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.######}\t{1:0.######}\t\t\t\t\t\tcompressive sound speed profile in substrate [depth (m), sound speed (m/s)]", 0.0, sedimentType.CompressionWaveSpeed)); envFile.WriteLine("-1\t-1"); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.######}\t{1:0.######}\t\t\t\t\t\tdensity profile in substrate [depth (m), rhob (g/cm³)]", 0.0, sedimentType.Density)); envFile.WriteLine("-1\t-1"); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.######}\t{1:0.######}\t\t\t\t\t\tcompressive attenuation profile in substrate [depth (m), attnp (db/lambda)]", 0.0, 0.0)); envFile.WriteLine(string.Format(CultureInfo.InvariantCulture, "{0:0.######}\t{1:0.######}", attenuationLayerDz, 40)); envFile.WriteLine("-1\t-1"); firstRangeProfile = false; } } var tempDirectory = Path.Combine(Path.GetTempPath(), Path.GetFileNameWithoutExtension(envFileName)); //Debug.WriteLine(string.Format("Env File: {0} temp path: {1}", envFileName, tempDirectory)); if (Directory.Exists(tempDirectory)) { var files = Directory.GetFiles(tempDirectory, "*.*"); foreach (var file in files) File.Delete(file); Directory.Delete(tempDirectory, true); } else if (File.Exists(tempDirectory)) File.Delete(tempDirectory); Directory.CreateDirectory(tempDirectory); File.Copy(envFileName, Path.Combine(tempDirectory, "ramgeo.in")); using (var steerableArrayFile = new StreamWriter(Path.Combine(tempDirectory, "sra.in"), false)) { // From http://www.activefrance.com/Antennas/Introduction%20to%20Phased%20Array%20Design.pdf // theta3 = 3dB beam width, in degrees // emitterSize = size of emitter array, in meters // theta3 = (0.886 * lambda / arrayLength) * 180 / pi // so, doing the algebra and solving for arrayLength, you get: // emitterSize = (0.886 * lambda) / (theta3 * (pi / 180)) var emitterSize = (0.886 * lambda) / (mode.VerticalBeamWidth * (Math.PI / 180.0)); var emitterCount = (int)(emitterSize / (dz * 2)); var emitterSpacing = 1.0; var weights = new List<double> { 1 }; if (emitterCount > 1) { emitterSpacing = emitterSize / (emitterCount - 1); // chebyshev window calculations for relative emitter strength across the array var discreteFourierTransform = new MathNet.Numerics.IntegralTransforms.Algorithms.DiscreteFourierTransform(); var r0 = Math.Pow(10, mode.SideLobeAttenuation / 20.0); var n = emitterCount - 1; var a = Complex.Cosh((1.0 / n) * Acosh(r0)); var am = new Complex[n]; for (var m = 0; m < n; m++) am[m] = a * Complex.Cos(Math.PI * m / n); var wm = new Complex[n]; var sign = 1; for (var i = 0; i < n; i++) { if (am[i].Magnitude > 1) wm[i] = sign * Complex.Cosh(n * Acosh(am[i])); else wm[i] = sign * Complex.Cos(n * Complex.Acos(am[i])); sign *= -1; } discreteFourierTransform.BluesteinInverse(wm, FourierOptions.Default); weights = wm.Select(e => e.Real).ToList(); weights[0] /= 2; weights.Add(weights[0]); var maxWeight = weights.Max(); for (var i = 0; i < weights.Count; i++) weights[i] /= maxWeight; } steerableArrayFile.WriteLine("{0}\t{1}\t{2}", emitterCount, emitterSpacing, mode.DepressionElevationAngle); for (var i = 0; i < emitterCount; i++) steerableArrayFile.WriteLine("{0}", weights[i]); } //File.Copy(Path.Combine(AssemblyLocation, "sra.in"), Path.Combine(tempDirectory, "sra.in")); //Debug.WriteLine(string.Format("Env File: {0} copied to: {1}", envFileName, tempDirectory)); // Now that we've got the files ready to go, we can launch bellhop to do the actual calculations var ramProcess = new Process { StartInfo = new ProcessStartInfo(Path.Combine(AssemblyLocation, "RAMGeo.exe")) { CreateNoWindow = true, UseShellExecute = false, RedirectStandardInput = false, RedirectStandardOutput = true, RedirectStandardError = true, WorkingDirectory = tempDirectory } }; if (radial.IsDeleted) throw new RadialDeletedByUserException(); ramProcess.Start(); try { ramProcess.PriorityClass = ProcessPriorityClass.Idle; } catch (InvalidOperationException) { } //ramProcess.BeginOutputReadLine(); while (!ramProcess.HasExited) { if (radial.IsDeleted) { ramProcess.Kill(); throw new RadialDeletedByUserException(); } Thread.Sleep(20); } var ramOutput = ramProcess.StandardOutput.ReadToEnd(); var ramError = ramProcess.StandardError.ReadToEnd(); if (ramProcess.ExitCode != 0) { Debug.WriteLine("RAMGeo process for radial {0} exited with error code {1:X}", radial.BasePath, ramProcess.ExitCode); Debug.WriteLine(ramError); Directory.Delete(tempDirectory, true); return; } //File.Delete(Path.Combine(tempDirectory, "ramgeo.in")); //File.Delete(radial.BasePath + ".grid"); //File.Move(Path.Combine(tempDirectory, "tl.grid"), radial.BasePath + ".grid"); //File.Delete(radial.BasePath + ".line"); //File.Move(Path.Combine(tempDirectory, "tl.line"), radial.BasePath + ".line"); //File.Delete(radial.BasePath + ".pgrid"); //File.Move(Path.Combine(tempDirectory, "p.grid"), radial.BasePath + ".pgrid"); //File.Delete(radial.BasePath + ".sra"); //File.Move(Path.Combine(tempDirectory, "sra.in"), radial.BasePath + ".sra"); using (var writer = new StreamWriter(radial.BasePath + ".bty")) writer.Write(bottomProfile.ToBellhopString()); if (File.Exists(Path.Combine(tempDirectory, "p.grid"))) { var pressures = ReadPGrid(Path.Combine(tempDirectory, "p.grid")); File.Copy(Path.Combine(tempDirectory, "p.grid"), radial.BasePath + ".pgrid", true); //File.Delete(radial.BasePath + ".pgrid"); if (pressures.Count == 0) { Debug.WriteLine("Temp directory: " + tempDirectory); Debug.WriteLine("RAMGeo stdout: " + ramOutput); Debug.WriteLine("RAMGeo stderr: " + ramError); Directory.Delete(tempDirectory, true); return; } var rangeCount = pressures.Count; var depthCount = pressures[0].Length; var rr = new double[rangeCount]; var rd = new double[depthCount]; for (var rangeIndex = 0; rangeIndex < rr.Length; rangeIndex++) rr[rangeIndex] = (rangeIndex + 1) * dr * ndr; for (var depthIndex = 0; depthIndex < rd.Length; depthIndex++) rd[depthIndex] = depthIndex * zstep; //Debug.WriteLine("Scenario: '{0}' Mode: '{2}' Analysis point: {1} Bearing: {3}, zmplt: {4}, zstep: {5}, maxDepth: {6}, fileName: {7}, reqDepthCells: {8}, actualDepthCells: {9}", // radial.TransmissionLoss.AnalysisPoint.Scenario.Name, // radial.TransmissionLoss.AnalysisPoint.Geo, // radial.TransmissionLoss.Modes[0].ModeName, // radial.Bearing, // zmplt, // zstep, // rd.Last(), // Path.GetFileNameWithoutExtension(radial.BasePath), // zmplt / zstep, // depthCount); var shadeFile = new ShadeFile(sourceDepth, frequency, rd, rr, pressures); shadeFile.Write(radial.BasePath + ".shd"); //BellhopOutput.WriteShadeFile(radial.BasePath + ".shd", sourceDepth, frequency, rd, rr, pressures); } else { //Debug.WriteLine("Scenario: {0} Analysis point: {1} Mode {2} Bearing {3}", // radial.TransmissionLoss.AnalysisPoint.Scenario.Name, // radial.TransmissionLoss.AnalysisPoint.Geo, // radial.TransmissionLoss.Modes[0].ModeName, // radial.Bearing); //Debug.WriteLine("p.grid file not found in RAMGeo output directory"); } Directory.Delete(tempDirectory, true); //Debug.WriteLine(string.Format("Env File: {0} temp directory deleted: {1}", envFileName, tempDirectory)); }
public static ShadeFile Read(string bellhopFilename, float bearingFromSource) { var shadeFile = new ShadeFile { BearingFromSource = bearingFromSource }; var retry = 20; while (!File.Exists(bellhopFilename) && retry > 0) { Thread.Sleep(50); retry--; } using (var reader = new BinaryReader(new FileStream(bellhopFilename, FileMode.Open, FileAccess.Read))) { var recordLength = reader.ReadInt32() * 4; shadeFile.Title = new string(reader.ReadChars(80)).Trim(); reader.BaseStream.Seek(recordLength, SeekOrigin.Begin); shadeFile.PlotType = new string(reader.ReadChars(10)); shadeFile.Xs = reader.ReadSingle(); shadeFile.Ys = reader.ReadSingle(); reader.BaseStream.Seek(2 * recordLength, SeekOrigin.Begin); shadeFile.Frequency = reader.ReadSingle(); //Theta = new float[reader.ReadInt32()]; var thetaCount = reader.ReadInt32(); shadeFile.SourceDepths = new float[reader.ReadInt32()]; shadeFile.ReceiverDepths = new float[reader.ReadInt32()]; shadeFile.ReceiverRanges = new float[reader.ReadInt32()]; reader.BaseStream.Seek(3 * recordLength, SeekOrigin.Begin); for (var curTheta = 0; curTheta < thetaCount; curTheta++) reader.ReadSingle(); reader.BaseStream.Seek(4 * recordLength, SeekOrigin.Begin); for (var source = 0; source < shadeFile.SourceDepths.Length; source++) shadeFile.SourceDepths[source] = reader.ReadSingle(); reader.BaseStream.Seek(5 * recordLength, SeekOrigin.Begin); for (var depth = 0; depth < shadeFile.ReceiverDepths.Length; depth++) shadeFile.ReceiverDepths[depth] = reader.ReadSingle(); reader.BaseStream.Seek(6 * recordLength, SeekOrigin.Begin); int range; for (range = 0; range < shadeFile.ReceiverRanges.Length; range++) shadeFile.ReceiverRanges[range] = reader.ReadSingle(); shadeFile._pressure = new Complex[shadeFile.ReceiverDepths.Length, shadeFile.ReceiverRanges.Length]; for (var curTheta = 0; curTheta < thetaCount; curTheta++) { for (var source = 0; source < shadeFile.SourceDepths.Length; source++) { for (var depth = 0; depth < shadeFile.ReceiverDepths.Length; depth++) { var recordNumber = 7 + (curTheta * shadeFile.SourceDepths.Length * shadeFile.ReceiverDepths.Length) + (source * shadeFile.ReceiverDepths.Length) + depth; reader.BaseStream.Seek(recordNumber * recordLength, SeekOrigin.Begin); for (range = 0; range < shadeFile.ReceiverRanges.Length; range++) shadeFile._pressure[depth, range] = new Complex(reader.ReadSingle(), reader.ReadSingle()); } // for Depth } // for Source } // for CurTheta } // using shadeFile.DataMin = shadeFile.StatMin = float.MaxValue; shadeFile.DataMax = shadeFile.StatMax = float.MinValue; shadeFile.ExtractStatisticalData(); return shadeFile; }
public void ReleaseAxisData() { _ranges = null; _depths = null; _bottomProfile = null; _minimumTransmissionLossValues = null; _maximumTransmissionLossValues = null; _shadeFile = null; }
public void Recalculate() { IsCalculated = false; _bottomProfile = null; _shadeFile = null; _depths = _ranges = null; _minimumTransmissionLossValues = _maximumTransmissionLossValues = _meanTransmissionLossValues = null; var files = Directory.GetFiles(Path.GetDirectoryName(BasePath), Path.GetFileNameWithoutExtension(BasePath) + ".*"); foreach (var file in files) FileDeleteWithRetry(file); Globals.TransmissionLossCalculatorService.Add(this); }
public bool ExtractAxisData(int debugIndex = -1) { try { try { if (BasePath == null || File.Exists(BasePath + ".axs") || !File.Exists(BasePath + ".shd")) return false; if (_shadeFile == null) _shadeFile = ShadeFile.Read(BasePath + ".shd", (float)Bearing); if (_bottomDepths != null) _shadeFile.BottomDepths = _bottomDepths; } catch (EndOfStreamException) { FileDeleteWithRetry(BasePath + ".shd"); Globals.TransmissionLossCalculatorService.Add(this); return false; } _ranges = _shadeFile.ReceiverRanges.ToArray(); _depths = _shadeFile.ReceiverDepths.ToArray(); IsCalculated = true; _bottomProfile = ESME.TransmissionLoss.Bellhop.BottomProfile.FromBellhopFile(BasePath + ".bty"); _minimumTransmissionLossValues = new float[Ranges.Length]; _maximumTransmissionLossValues = new float[Ranges.Length]; _meanTransmissionLossValues = new float[Ranges.Length]; _bottomDepths = new float[Ranges.Length]; for (var rangeIndex = 0; rangeIndex < Ranges.Length; rangeIndex++) { //if (debugIndex >= 0 && rangeIndex == debugIndex) Debugger.Break(); // Updated to ignore values below the bottom var curRange = _ranges[rangeIndex]; var depthAtThisRange = (from profilePoint in BottomProfile let desiredRange = Math.Abs((profilePoint.Range * 1000) - curRange) orderby desiredRange select profilePoint.Depth).Take(2).Min(); _bottomDepths[rangeIndex] = (float)depthAtThisRange; if (depthAtThisRange <= _depths[0]) { MinimumTransmissionLossValues[rangeIndex] = float.NaN; MaximumTransmissionLossValues[rangeIndex] = float.NaN; MeanTransmissionLossValues[rangeIndex] = float.NaN; continue; } var bottomDepthIndex = _depths.ToList().IndexOf((from depth in _depths let curDepth = depthAtThisRange - depth where curDepth > 0 orderby curDepth select depth).First()); var tlValuesAboveBottom = _shadeFile[rangeIndex].Take(bottomDepthIndex).Where(v => !float.IsNaN(v) && !float.IsInfinity(v)).ToList(); if (tlValuesAboveBottom.Count == 0) { MinimumTransmissionLossValues[rangeIndex] = float.NaN; MaximumTransmissionLossValues[rangeIndex] = float.NaN; MeanTransmissionLossValues[rangeIndex] = float.NaN; continue; } if (debugIndex >= 0 && rangeIndex == debugIndex) { var maxTransmissionLoss = tlValuesAboveBottom.Max(); var maxTransmissionLossDepthIndex = _shadeFile[rangeIndex].IndexOf(maxTransmissionLoss); var maxTransmissionLossDepth = _depths[maxTransmissionLossDepthIndex]; Debug.WriteLine("Maximum TL value for this field found at radial bearing {0}, range {1}, depth {2}, TL {3}, bottom depth at this range {4}", Bearing, curRange, maxTransmissionLossDepth, maxTransmissionLoss, depthAtThisRange); } MinimumTransmissionLossValues[rangeIndex] = tlValuesAboveBottom.Min(); MaximumTransmissionLossValues[rangeIndex] = tlValuesAboveBottom.Max(); MeanTransmissionLossValues[rangeIndex] = tlValuesAboveBottom.Average(); } _shadeFile.BottomDepths = _bottomDepths; using (var writer = new BinaryWriter(new FileStream(BasePath + ".axs", FileMode.Create))) { writer.Write(_ranges.Length); foreach (var range in _ranges) writer.Write(range); writer.Write(_depths.Length); foreach (var depth in _depths) writer.Write(depth); writer.Write(_minimumTransmissionLossValues.Length); foreach (var tl in _minimumTransmissionLossValues) writer.Write(tl); writer.Write(_maximumTransmissionLossValues.Length); foreach (var tl in _maximumTransmissionLossValues) writer.Write(tl); writer.Write(_meanTransmissionLossValues.Length); foreach (var tl in _meanTransmissionLossValues) writer.Write(tl); writer.Write(_bottomDepths.Length); foreach (var depth in _bottomDepths) writer.Write(depth); } //MediatorMessage.Send(MediatorMessage.TransmissionLossLayerChanged, TransmissionLoss); return true; } catch (Exception) { if (IsDeleted) return false; throw; } }