/// <summary> /// Creates a deep copy of a given channel /// </summary> /// <param name="c"></param> public virtual Oilfield_Channel Clone() { Oilfield_Channel tmp = new Oilfield_Channel(); tmp.Name = this.Name; tmp.Unit = this.Unit; tmp.Description = this.Description; tmp.DepthOffset = this.DepthOffset; tmp.Decimals_Count = this.Decimals_Count; tmp.Format = this.Format; tmp.PaddedWidth = this.PaddedWidth; tmp.ValidCount = this.ValidCount; tmp.MissingCount = this.MissingCount; tmp.DataStart = this.DataStart; tmp.DataEnd = this.DataEnd; tmp.DataStartIndex = this.DataStartIndex; tmp.DataEndIndex = this.DataEndIndex; tmp.MinValue = this.MinValue; tmp.MaxValue = this.MaxValue; tmp.Average = this.Average; foreach (Oilfield_Constant d in this.Parameters) { tmp.Parameters.Add(d.Clone()); } foreach (double d in this.Data) { tmp.Data.Add(d); } return(tmp); }
/// <summary> /// Returns the channel average from start to end depth inclusive. /// </summary> /// <param name="start">start index</param> /// <param name="end">end index</param> /// <param name="index">index channel</param> /// <returns>ariphmetic average or NaN</returns> public virtual double GetAverage(double start, double end, Oilfield_Channel index) { double average = 0.0; double averageCount = 0.0; for (int i = 0; i < Data.Count; i++) { double d = index.Data[i]; if (d < start || end < d) { continue; } d = Data[i]; if (Double.IsNaN(d)) { continue; } average += d; averageCount += 1.0; } if (averageCount <= 0.0) { return(Double.NaN); } return(average /= averageCount); }
/// <summary> /// Creates a deep copy of a given channel /// </summary> /// <param name="c"></param> public Oilfield_Channel(Oilfield_Channel c) { this.Name = c.Name; this.Unit = c.Unit; this.Description = c.Description; this.DepthOffset = c.DepthOffset; this.Decimals_Count = c.Decimals_Count; this.Format = c.Format; this.PaddedWidth = c.PaddedWidth; this.ValidCount = c.ValidCount; this.MissingCount = c.MissingCount; this.DataStart = c.DataStart; this.DataEnd = c.DataEnd; this.DataStartIndex = c.DataStartIndex; this.DataEndIndex = c.DataEndIndex; this.MinValue = c.MinValue; this.MaxValue = c.MaxValue; this.Average = c.Average; foreach (Oilfield_Constant d in c.Parameters) { this.Parameters.Add(d); } foreach (double d in c.Data) { this.Data.Add(d); } }
/// <summary> /// Loads the channel info from disk /// </summary> /// <param name="filename">filename to load from</param> /// <returns>true if file exists and loaded</returns> public bool Load(string filename) { if (!File.Exists(filename)) { return(false); } StreamReader sr = File.OpenText(filename); bool ret = true; while (true) { string s = sr.ReadLine(); if (s == null) { break; } if (s.Length <= 0) { continue; } if (s.StartsWith("#")) { continue; } s = Dequote(s); string[] tmp = s.Split(c_Splitters, StringSplitOptions.None); if (tmp.Length < 9) { ret = false; continue; } Oilfield_Channel oc = null; foreach (Oilfield_Channel c in m_Channels) { if (c.Name != tmp[0] || c.Unit != tmp[1]) { continue; } oc = c; break; } if (oc == null) { ret = false; continue; } try { oc.FromStrings(tmp); } catch (Exception) { ret = false; continue; } } sr.Close(); return(ret); }
/// <summary> /// Updates the channel statistics for all channels in file /// </summary> public virtual void UpdateChannelStatistics() { for (int i = 0; i < Channels.Count; i++) { Oilfield_Channel oc = GetChannel(i); oc.LocateDataBoundaries(this.GetIndex()); } }
/// <summary> /// Applies a simple depth offset on the channel data /// </summary> /// <param name="step"></param> public void ApplyDepthOffsets() { Oilfield_Channel index = GetIndex(); double step = index.Data[1] - index.Data[0]; for (int i = 1; i < Channels.Count; i++) { Channels[i].ApplyDepthOffset(step); } }
/// <summary> /// Creates the same channes as in the given file /// </summary> /// <param name="file"></param> public virtual void CreateSameChannels(Oilfield_File file) { for (int i = 1; i < file.Channels.Count; i++) { Oilfield_Channel lc = file.Channels[i]; Oilfield_Channel tmp = this.GetChannel(lc.Name); if (tmp != null) { continue; } this.GetOrCreateChannel(lc.Name, lc.Unit, lc.Description, lc.Format); } }
/// <summary> /// Returns a new channel /// </summary> public virtual Oilfield_Channel GetNewChannel(string name, string unit, string description) { Oilfield_Channel c = GetIndexCopy(); if (c != null) { c.Name = name; c.Unit = unit; c.Description = description; c.SetData(Double.NaN); } return(c); }
/// <summary> /// Returns a new LAS channel /// </summary> public virtual Oilfield_Channel GetNewChannel(Oilfield_Channel template) { Oilfield_Channel c = new Oilfield_Channel(template); Oilfield_Channel index = GetIndex(); if (c != null) { c.Data.Clear(); for (int i = 0; i < index.Data.Count; i++) { c.Data.Add(Double.NaN); } } return(c); }
/// <summary> /// Returns the channel, creating one as necessary /// </summary> public virtual Oilfield_Channel GetOrCreateChannel(string name, string unit, string description, string format) { Oilfield_Channel c = GetChannel(name); if (c != null) { return(c); } c = GetIndexCopy(); c.Name = name; c.Unit = unit; c.Description = description; c.Format = format; c.SetData(Double.NaN); Channels.Add(c); return(c); }
/// <summary> /// Locates the upper and lower boundaries for the channel /// </summary> /// <param name="index">index channel or null</param> /// <returns>true is boundearies are located</returns> public virtual bool LocateDataBoundaries(Oilfield_Channel index) { ValidCount = 0; MissingCount = 0; DataStart = Double.NaN; DataEnd = Double.NaN; DataStartIndex = -1; DataEndIndex = -1; MinValue = Double.NaN; MaxValue = Double.NaN; Average = Double.NaN; if (Data.Count <= 0) { return(false); } if (index != null) { DataStart = index.Data[0]; DataEnd = index.Data[Data.Count - 1]; } DataStartIndex = 0; DataEndIndex = Data.Count - 1; bool data_located = false; for (int i = 0; i < Data.Count; i++) { DataStartIndex = i; if (!Double.IsNaN(Data[i])) { data_located = true; break; } } if (!data_located) { ValidCount = 0; MissingCount = Data.Count; return(false); } if (index != null) { DataStart = index.Data[DataStartIndex]; } data_located = false; for (int i = Data.Count - 1; i >= 0; i--) { DataEndIndex = i; if (!Double.IsNaN(Data[i])) { data_located = true; break; } } if (!data_located) { ValidCount = 0; MissingCount = Data.Count; return(false); } if (index != null) { DataEnd = index.Data[DataEndIndex]; } MinValue = Double.MaxValue; MaxValue = Double.MinValue; Average = 0.0; double AverageCount = 0.0; for (int i = 0; i < Data.Count; i++) { double d = Data[i]; if (Double.IsNaN(d)) { MissingCount++; continue; } ValidCount++; if (MinValue > d) { MinValue = d; } if (MaxValue < d) { MaxValue = d; } Average += d; AverageCount += 1.0; } Average /= AverageCount; return(true); }