TheTechIdea OilGas - Developer guide User guide →

TheTechIdea.OilGas.Wellbore.Loaders

61 public types. Summaries come from the XML documentation of the compiled assembly.

TheTechIdea.OilGas.Wellbore.Loaders

TypeSummary
BuiltInDataSourceFactoryclassThe built-in data source kinds: csv (folder), excel (.xlsx), edmXml (Landmark EDM export).
CodeObservationclassA code value of a source: raw, as resolved, its vocabulary domain (or lexicon / unit) and the well it was seen in.
CoverageItemclassA value of a source that does not resolve: where, how often, an example well, what is wrong and the setting that fixes it.
CoverageOptionsclassOptions of a coverage analysis.
CoverageReportclassWhat a source holds that the environment does not resolve.
CsvTabularSourceclassFolder of CSV files, one per table ({table}.csv, header row, RFC 4180 quoting). Missing file = empty table.
DataCoveragestatic classCoverage of a configured data source: every code, top name, lithology, unit and log mnemonic it holds that the environment does not resolve - with counts, an example well and the setting that fixes it (wellbore-config coverage).
DataRowclassRow shape returned by tabular sources: column name (case-insensitive) -> value.
DataSourcesstatic classThe environment's data sources (dataSources): open one by name with its mapping profile and the company's overrides (code values, row filters), or load a well from it - tabular sources through the profile, LAS / DLIS / WITSML files through their readers. "dataSource" verification cases check a source against what the company expects (Evaluators).
DlisAttributeEntryclassAn attribute of a DLIS object: values (decoded by representation code), units and the code.
DlisFileclassReads DLIS files (API RP66 version 1): the storage unit label (found after leading bytes or absent), visible records and logical record segments (padding, checksums, trailing lengths), Tape Image Format wrapping, explicit records (sets, templates, objects, absent and default attributes), frame data and all 27 representation codes. Encrypted records are skipped with a warning; a malformed file gives a InvalidDataException describing where, never a crash.
DlisFrameDataclassA frame's samples: frame numbers and, per channel, one sample array per frame (length = product of the channel dimension).
DlisLoadResultclassResult of loading a DLIS file: the well model with its log sets, the decoded file and the warnings.
DlisLogicalFileclassA logical file: its objects and frame data.
DlisNamestructAn object name (RP66 OBNAME): origin, copy number and identifier.
DlisObjectclassA DLIS object (one row of an explicit set): type, name and attributes.
DlisObjectRefstructAn object reference (RP66 OBJREF): object type and name.
DlisReaderstatic classLoads DLIS (API RP66 v1) logs into the canonical model: the ORIGIN object names the well (name, id, field, company - kept when the model already has them), every frame becomes a log set indexed by its first channel (depth, or time when INDEX-TYPE is TIME), and scalar channels become its curves. Array channels (waveforms, images) and unreadable frames are listed in the warnings.
DlisReadOptionsclassOptions for turning DLIS frames into log sets.
EdmXmlTabularSourceclassA Landmark EDM XML export (as written by COMPASS / WELLPLAN / OpenWells data transfer) as tabular source: every element that carries attributes is a row of the table named by the element (CD_WELL, CD_WELLBORE, CD_HOLE_SECT...), its attributes the columns. Use with the "edm" mapping profile.
EntityMapclassHow one canonical entity is read from one source table.
ExcelTabularSourceclassAn Excel workbook (.xlsx, Office Open XML SpreadsheetML - ECMA-376) as tabular source: each worksheet is a table named by the sheet, its first row the column headers. Numbers come as Double, booleans as Boolean, date cells (by their number format, 1900 or 1904 date system) as ISO 8601 text, errors as null. Read with System.IO.Compression and XML - no dependency. Formulas give their cached values (as Excel last saved them).
ExportFileclassOne exported file: name and content.
FieldQcstatic classField-wide QC: every well of a data source - completeness, the built-in checks (QC001-QC006), load warnings, equipment rules and an optional host validator - aggregated by issue code; wells are processed one at a time and not kept, so memory stays flat.
FieldQcOptionsclassOptions of a field QC run.
FieldQcReportclassResult of a field QC run (aggregates only - the wells themselves are not kept).
IDataSourceFactoryinterfaceOpens the tabular data source a DataSourceDefinition describes. The built-in factory knows csv, excel and edmXml; a host adds its own kinds (for example a database by connection name) with WellboreServices.Set<IDataSourceFactory>.
InMemoryTabularSourceclassIn-memory tables (tests, caching, pre-fetched API results).
ITabularSourceinterfaceMinimal read contract every tabular backend implements: equality-filtered queries on one table. SQL databases (PPDM, Seabed, EDM via BeepDM IDataSource), CSV folders, REST gateways… all fit.
IWellDataProviderinterfaceAnything that can produce the library's canonical WellModel.
JoinMapclassHow a related table joins an entity's rows: on is a column of both tables, or "localColumn=relatedColumn".
Las3Checkerstatic classChecks a LAS 3.0 file against the structure rules of the CWLS "LAS 3.0 File Structure Specifications" (Release 3.00, June 2000) - the checks LAS Certify 3.0 lists: ~Version / ~Well order and required lines, section titles, data / definition associations and channel counts, consistent delimiters, index and number formats, log data last with its parameter section, STRT / STOP / STEP against the log data, and association mnemonics. Returns the violations (empty = compliant).
LasLoadResultclassResult of reading a LAS file: the model, the log set, the LAS standard and any warnings.
LasReaderstatic classReads LAS 2.0 / 3.0 into the canonical model: well header (WELL, UWI, COMP, FLD, SRVC… -> header / extras) and one depth log set (index = DEPT / DEPTH / MD / TVD / TVDSS, else the first curve; NULL values -> null). WRAP YES data is read as a token stream chunked by curve count (a row spans several lines); WRAP NO reads one row per line and tolerates short lines. LAS 3.0 ~Log_Definition / ~Log_Data sections are recognised (comma or space delimited). Never throws on malformed or hostile input: problems become warnings / HasErrors.
LasReadOptionsclassOptions for reading large LAS files: curve selection, depth window, bounded envelope decimation.
LasWriteOptionsclassOptions for writing LAS: version, null value, decimals.
LasWriterstatic classWrites a depth log set (and the well header) as LAS 2.0 or 3.0; read back by LasReader without loss.
MappedWellDataProviderclassGeneric adapter: reads any tabular source through a MappingProfile into the canonical WellModel. Handles unit columns / defaults, code translation, vertical property tables, provenance and preservation of unmapped columns. Problems become warnings, never silent drops.
MappingProfileclassData-driven mapping from a source schema to the canonical WellModel. New source systems or schema versions = new profile JSON, no code. Entities: well, wellbore, holeSection, string, component, interval, top, survey.
OsduExportstatic classOSDU records of a well, per the OSDU data definitions (master-data--Wellbore 1.5.1, work-product-component--WellboreTrajectory 1.4.0, work-product-component--WellLog 1.5.0): ids and references in the data partition's namespace, depths in metres, curve units as UnitOfMeasure references (percent-encoded), acl / legal from the environment's osdu section.
PaySummaryExportstatic classPay summary exports.
PropertyTableMapclassPPDM-style vertical property table (property type / value rows) feeding canonical attributes.
QcIssueclassOne issue found in a well.
QcIssueGroupclassOne issue code across the field.
TabularTableclassA table produced by TabularWriter: name, column order and rows.
TabularWriterstatic classWrites a WellModel through a mapping profile - the exact reverse of MappedWellDataProvider: the profile's tables and columns, unit columns, per-field code maps (canonical -> source code) and captured extra columns. A customer layout (another profile) is written in that layout. Values sharing a unit column are converted to one unit.
WellLoadResultclassResult of loading a well from a data source: the canonical model and any mapping warnings.
WellQcRowclassWhat one well has, and how many issues it raised.
WellSummaryclassA well listed by a data source (id and name) before it is loaded.
Witsml21Exportstatic classWITSML 2.1 data objects of a well (Energistics WITSML v2.1 / common v2.3 schemas): Well, Wellbore, Trajectory (with stations), and per depth log set a Log whose ChannelSet holds the Channels and references its bulk data by FileUri - a LAS 3.0 file written alongside (the schema's business rule: Data or FileUri; the inline JSON layout is not specified, so it is not used). Channels reference their property kind from the Energistics property kind dictionary (v2.3) and a BusinessAssociate (the logging company). UUIDs are name-based (stable across exports).
WitsmlGrowingLogSourceclassGrowing-log source over a WITSML store: the constructor's query delegate performs the transport call (e.g. WMLS_GetFromStore / ETP with a startIndex) and returns the WITSML logs XML; only rows strictly after the last index are returned, so a store that ignores startIndex, or re-sends overlapping rows, is handled. Depth-indexed logs only.
WitsmlLoadResultclassResult of reading WITSML documents: the model, counts of stations, markers and logs, and warnings.
WitsmlLogReferenceclassThe log a growing-log source follows.
WitsmlQueriesstatic classWITSML 1.4.1.1 queries.
WitsmlReaderstatic classReads WITSML trajectories, formation markers and logs into the canonical model. Elements are matched by local name, case-insensitively, so WITSML 1.3.1.1 / 1.4.1.1 (lowercase, "1series" namespace) and 2.0 (PascalCase) trajectories read alike. Units come from each value's uom: angles in dega / deg / rad (public field data often uses rad), lengths in any known unit including the US survey foot "ft[US]" (converted exactly, 1200/3937 m). Depth-indexed logs only; time-indexed logs are reported, not mis-read.
WitsmlStoreClientclassClient for a WITSML 1.4.1.1 store over SOAP 1.1 (WMLS_GetVersion, WMLS_GetFromStore): basic authentication (https required unless allowed), timeout, retries with doubling delay for transient failures only (network errors, timeouts, HTTP 5xx without a SOAP fault); SOAP faults and negative WITSML results are raised as WitsmlStoreException. Message namespace and SOAPAction prefix follow the standard WSDL and can be changed for stores that differ.
WitsmlStoreExceptionclassA store call that failed: SOAP fault, WITSML error result, HTTP error or retries exhausted.
WitsmlStoreOptionsclassConnection settings of a WITSML 1.4.1.1 store (SOAP).
WitsmlStoreResultclassThe reply of a store method: WITSML result code (positive = success), returned XML and the server's message.
WitsmlWriterstatic classWrites WITSML 1.4.1.1 trajectories, formation markers and depth logs ("1series" namespace), read back by WitsmlReader without loss. Fluid contacts have no field in a 1.4.1.1 formationMarker: they are written as markers with their names, the contact type is not carried.
XlsxWriterstatic classA minimal Excel (.xlsx, Office Open XML) writer: one sheet, numbers as numbers, text as inline strings - no dependencies.

BuiltInDataSourceFactory class

The built-in data source kinds: csv (folder), excel (.xlsx), edmXml (Landmark EDM export).

Inherits / implements: IDataSourceFactory

MemberSummary
ITabularSource Open(string name, DataSourceDefinition definition, string resolvedPath)Opens a csv folder, an Excel workbook or an EDM XML export; null for other kinds.

CodeObservation class

A code value of a source: raw, as resolved, its vocabulary domain (or lexicon / unit) and the well it was seen in.

MemberSummary
CodeObservation(string entity, string field, string raw, string resolved, string domain, string wellId)Creates an observation.
string Domain { get; }Vocabulary domain, or "lexicon" / "unit".
string Entity { get; }Canonical entity (string, component, top...).
string Field { get; }Canonical field (kind, type, name, top.unit...).
string Raw { get; }The value in the source.
string Resolved { get; }The value after the profile and vocabularies (for top names: the lexicon unit id; null when unresolved).
string WellId { get; }Well the value was seen in.

CoverageItem class

A value of a source that does not resolve: where, how often, an example well, what is wrong and the setting that fixes it.

MemberSummary
string Area { get; set; }codes, catalog, symbols, lexicon, lithology, units or mnemonics.
int Count { get; set; }Occurrences.
string ExampleWell { get; set; }A well holding it.
string Fix { get; set; }The environment setting that fixes it.
string Problem { get; set; }What is wrong.
string Resolved { get; set; }The value after mapping, when different.
string Value { get; set; }The value in the source.
string Where { get; set; }Entity.field the value is in.

CoverageOptions class

Options of a coverage analysis.

MemberSummary
Func<string, bool> LithologyKnown { get; set; }Whether a lithology code is in the lithology library in effect (the rendering library supplies it; null: not checked).
int MaxWells { get; set; }Most wells scanned when none are named.
Func<string, bool> SymbolKnown { get; set; }Whether a component type has a schematic symbol (the schematic library supplies it; null: not checked).
List<string> WellIds { get; set; }Wells to scan (none: all wells of a tabular source, up to MaxWells).

CoverageReport class

What a source holds that the environment does not resolve.

MemberSummary
Dictionary<string, int> Checked { get; }Distinct values checked per area.
List<string> Failed { get; }Wells that could not be loaded.
List<CoverageItem> Problems { get; }Values that do not resolve, most frequent first.
string Source { get; set; }The data source.
int Wells { get; set; }Wells scanned.
string Worksheet()A worksheet for the data manager: the unresolved codes as a dataSources.&lt;source&gt;.codes skeleton (canonical values to fill in) and to-do lists for the lexicon, lithology library, symbols, units and mnemonics. A working file - not configuration as it stands.

CsvTabularSource class

Folder of CSV files, one per table ({table}.csv, header row, RFC 4180 quoting). Missing file = empty table.

Inherits / implements: ITabularSource

MemberSummary
CsvTabularSource(string folder)A source reading &lt;table&gt;.csv files (RFC 4180, header row) from folder; the encoding is detected per file.
CsvTabularSource(string folder, string encoding)A source reading &lt;table&gt;.csv files from folder in encoding (null = detect per file).
Dictionary<string, string> Encodings { get; }Encoding each table file was read with (web name), by table.
static List<DataRow> Parse(string text)RFC 4180 CSV parsing (quoted fields, doubled quotes, embedded newlines).
Task<IReadOnlyList<DataRow>> QueryAsync(string table, IReadOnlyDictionary<string, object> equals, CancellationToken cancellationToken = null)Rows of &lt;table&gt;.csv whose columns equal the given values; a missing file gives no rows.

DataCoverage static class

Coverage of a configured data source: every code, top name, lithology, unit and log mnemonic it holds that the environment does not resolve - with counts, an example well and the setting that fixes it (wellbore-config coverage).

MemberSummary
static CoverageReport Analyse(string source, CoverageOptions options = null)Analyses the environment's data source source.

DataRow class

Row shape returned by tabular sources: column name (case-insensitive) -&gt; value.

Inherits / implements: Dictionary<string, object>

MemberSummary
DataRow()An empty row (column names are case-insensitive).
DataRow(IDictionary<string, object> values)An empty row (column names are case-insensitive).

DataSources static class

The environment's data sources (dataSources): open one by name with its mapping profile and the company's overrides (code values, row filters), or load a well from it - tabular sources through the profile, LAS / DLIS / WITSML files through their readers. "dataSource" verification cases check a source against what the company expects (Evaluators).

MemberSummary
static IReadOnlyDictionary<string, Func<ReferenceCase, ReferenceCaseResult>> Evaluators { get; }Evaluators this library adds to ReferenceCases.Run: "dataSource" - load a configured source and check what it gives.
static WellLoadResult LoadWell(string name, string wellId = null)A well from a source: tabular kinds through the profile (the first well when wellId is null); las, dlis and witsml files through their readers.
static MappedWellDataProvider OpenProvider(string name)A provider for a tabular source (csv, excel, edmXml, or a host kind) - the profile with the source's overrides.
static MappingProfile Profile(string name)The mapping profile of a tabular source: its named profile with the source's code values and row filters laid over it.
static string ResolvePath(DataSourceDefinition d)The source's path, resolved against the environment file's folder.

DlisAttributeEntry class

An attribute of a DLIS object: values (decoded by representation code), units and the code.

MemberSummary
string Error { get; set; }Why the values could not be decoded (for example an invalid date); null when decoded.
string Label { get; set; }Attribute label.
int RepresentationCode { get; set; }Representation code (1-27).
string Units { get; set; }Units.
List<object> Values { get; set; }Values (double, long, string, bool, DateTime, DlisName, DlisObjectRef, double[] for FSING1 / FSING2 / FDOUB1 / FDOUB2 / complex codes); null: no value.

DlisFile class

Reads DLIS files (API RP66 version 1): the storage unit label (found after leading bytes or absent), visible records and logical record segments (padding, checksums, trailing lengths), Tape Image Format wrapping, explicit records (sets, templates, objects, absent and default attributes), frame data and all 27 representation codes. Encrypted records are skipped with a warning; a malformed file gives a InvalidDataException describing where, never a crash.

MemberSummary
List<DlisLogicalFile> LogicalFiles { get; }The logical files.
List<string> Warnings { get; }Things skipped or repaired (encrypted records, unknown records).
static DlisFile Load(string path)Reads a DLIS file.
static DlisFile Read(byte[] bytes)Reads DLIS bytes.

DlisFrameData class

A frame's samples: frame numbers and, per channel, one sample array per frame (length = product of the channel dimension).

MemberSummary
List<DlisObject> Channels { get; }The frame's channels in order.
string Error { get; set; }Why the frame's samples could not be read (an undescribed channel, frame data shorter than its channels); null when read.
DlisObject Frame { get; set; }The FRAME object.
List<long> FrameNumbers { get; }Frame numbers in file order.
List<List<object[]>> Samples { get; }Samples per channel (index as Channels), per frame.

DlisLoadResult class

Result of loading a DLIS file: the well model with its log sets, the decoded file and the warnings.

MemberSummary
DlisFile File { get; set; }The decoded file: logical files, objects and frame data.
List<LogSet> LogSets { get; }Log sets created (one per readable frame).
WellModel Model { get; set; }The well (the one given, with the log sets added).
List<string> Warnings { get; }Problems met (from the file, and frames or channels that could not become curves).

DlisLogicalFile class

A logical file: its objects and frame data.

MemberSummary
List<DlisFrameData> Frames { get; }Frames with their samples.
List<DlisObject> Objects { get; }All objects in file order.
IEnumerable<DlisObject> OfType(string type)Objects of a type.

DlisName struct

An object name (RP66 OBNAME): origin, copy number and identifier.

MemberSummary
DlisName(long origin, int copy, string id)Creates a name.
int Copy { get; }Copy number.
string Id { get; }Identifier.
long Origin { get; }Origin (ORIGIN object reference).
bool Equals(DlisName o)True when origin, copy number and identifier are the same.
bool Equals(object obj)True when origin, copy number and identifier are the same.
int GetHashCode()Hash of origin, copy number and identifier.
string ToString()The name as origin.copy.identifier.

DlisObject class

A DLIS object (one row of an explicit set): type, name and attributes.

MemberSummary
Dictionary<string, DlisAttributeEntry> Attributes { get; }Attributes by label, in template order.
DlisName Name { get; set; }Object name.
string Type { get; set; }Object type (CHANNEL, FRAME, ORIGIN, PARAMETER...).
object First(string label)First value of an attribute, or null.

DlisObjectRef struct

An object reference (RP66 OBJREF): object type and name.

MemberSummary
DlisObjectRef(string type, DlisName name)Creates a reference.
DlisName Name { get; }Object name.
string Type { get; }Object type (set type).

DlisReader static class

Loads DLIS (API RP66 v1) logs into the canonical model: the ORIGIN object names the well (name, id, field, company - kept when the model already has them), every frame becomes a log set indexed by its first channel (depth, or time when INDEX-TYPE is TIME), and scalar channels become its curves. Array channels (waveforms, images) and unreadable frames are listed in the warnings.

MemberSummary
static DlisLoadResult Load(byte[] bytes, WellModel into = null, DlisReadOptions options = null)Loads DLIS bytes.
static DlisLoadResult LoadFile(string path, WellModel into = null, DlisReadOptions options = null)Loads a DLIS file.

DlisReadOptions class

Options for turning DLIS frames into log sets.

MemberSummary
List<double> NullValues { get; set; }Sample values that mean "no data" (DLIS has no standard marker): the environment's loaders.nullValues unless set.

EdmXmlTabularSource class

A Landmark EDM XML export (as written by COMPASS / WELLPLAN / OpenWells data transfer) as tabular source: every element that carries attributes is a row of the table named by the element (CD_WELL, CD_WELLBORE, CD_HOLE_SECT...), its attributes the columns. Use with the "edm" mapping profile.

Inherits / implements: ITabularSource

MemberSummary
EdmXmlTabularSource(Stream xml)Reads an export from a stream.
IReadOnlyDictionary<string, int> Tables { get; }Tables found in the export (element names), with their row counts.
static EdmXmlTabularSource FromFile(string path)Reads the export at path.
Task<IReadOnlyList<DataRow>> QueryAsync(string table, IReadOnlyDictionary<string, object> equals, CancellationToken cancellationToken = null)Rows of table whose columns equal the given values.

EntityMap class

How one canonical entity is read from one source table.

MemberSummary
Dictionary<string, Dictionary<string, string>> Codes { get; set; }Canonical field -&gt; (source code -&gt; canonical code).
Dictionary<string, string> DefaultUnits { get; set; }Canonical quantity field -&gt; unit used when no unit column/value is available.
Dictionary<string, string> Fields { get; set; }Canonical field -&gt; source column, or a formula over the row's numeric columns starting with '=' (for example "=md_shoe - length").
Dictionary<string, JoinMap> Joins { get; set; }Related tables joined to each row by a key (normalised models: WELL_EQUIPMENT -&gt; EQUIPMENT); fields then name "TABLE.COLUMN".
List<string> Key { get; set; }Columns forming the record key (provenance).
PropertyTableMap Properties { get; set; }Vertical property table (name / value rows) for this entity, if the source stores attributes that way.
string Table { get; set; }Source table of the entity.
Dictionary<string, string> Units { get; set; }Canonical quantity field -&gt; column holding its unit (PPDM *_OUOM).
string VersionColumn { get; set; }Optional column holding a version / source discriminator (PPDM SOURCE, OBS_NO…).
string WellColumn { get; set; }Column holding the well identifier (filter for per-well queries).
Dictionary<string, string> Where { get; set; }Only rows whose columns equal these values (for example a type code); combined with the well filter.

ExcelTabularSource class

An Excel workbook (.xlsx, Office Open XML SpreadsheetML - ECMA-376) as tabular source: each worksheet is a table named by the sheet, its first row the column headers. Numbers come as Double, booleans as Boolean, date cells (by their number format, 1900 or 1904 date system) as ISO 8601 text, errors as null. Read with System.IO.Compression and XML - no dependency. Formulas give their cached values (as Excel last saved them).

Inherits / implements: ITabularSource

MemberSummary
ExcelTabularSource(string path)Reads the workbook at path.
ExcelTabularSource(byte[] workbook)Reads the workbook at path.
IReadOnlyList<string> Tables { get; }Worksheet names (the tables), in workbook order.
List<string> Warnings { get; }Problems met while reading (missing parts, duplicate headers).
static bool IsDateFormat(string code)True when a number format code formats a date or time (quoted text, escapes, colours and locale tags ignored).
Task<IReadOnlyList<DataRow>> QueryAsync(string table, IReadOnlyDictionary<string, object> equals, CancellationToken cancellationToken = null)Rows of the sheet named table whose columns equal the given values; a missing sheet gives no rows.

ExportFile class

One exported file: name and content.

MemberSummary
ExportFile(string name, string content)Creates a file.
string Content { get; }File content.
string Name { get; }File name.

FieldQc static class

Field-wide QC: every well of a data source - completeness, the built-in checks (QC001-QC006), load warnings, equipment rules and an optional host validator - aggregated by issue code; wells are processed one at a time and not kept, so memory stays flat.

MemberSummary
static FieldQcReport Run(string source, FieldQcOptions options = null)Runs over the environment's data source source (tabular sources: every well; file sources: the one well).
static FieldQcReport Run(IWellDataProvider provider, string sourceName, FieldQcOptions options = null)Runs over every well of a provider.

FieldQcOptions class

Options of a field QC run.

MemberSummary
CancellationToken Cancellation { get; set; }Cancellation.
int MaxWells { get; set; }At most this many wells.
IProgress<(int, int)> Progress { get; set; }Progress: wells done, wells in total.
Func<WellModel, IEnumerable<QcIssue>> Validator { get; set; }Further validation per well (e.g. the schematic / log validators, supplied by a host that references them).

FieldQcReport class

Result of a field QC run (aggregates only - the wells themselves are not kept).

MemberSummary
List<string> Failed { get; }Wells that could not be loaded (id: reason).
bool HasErrors { get; }Whether any error was found (or a well failed to load).
List<QcIssueGroup> Issues { get; }Issues by code, most frequent first.
List<WellQcRow> Rows { get; }Per-well rows, worst first.
string Source { get; set; }Source name.
int Wells { get; }Wells checked.
string IssuesCsv()Issues by code as CSV.
string ToHtml()The report as a standalone HTML page, with the environment's trademark footnote.
string WellsCsv()Per-well completeness and issue counts as CSV.

IDataSourceFactory interface

Opens the tabular data source a DataSourceDefinition describes. The built-in factory knows csv, excel and edmXml; a host adds its own kinds (for example a database by connection name) with WellboreServices.Set&lt;IDataSourceFactory&gt;.

MemberSummary
ITabularSource Open(string name, DataSourceDefinition definition, string resolvedPath)The tabular source for definition (path already resolved), or null when this factory does not know its kind.

InMemoryTabularSource class

In-memory tables (tests, caching, pre-fetched API results).

Inherits / implements: ITabularSource

MemberSummary
InMemoryTabularSource Add(string table, IDictionary<string, object>[] rows)Adds rows to a table (created when missing); returns this source for chaining.
Task<IReadOnlyList<DataRow>> QueryAsync(string table, IReadOnlyDictionary<string, object> equals, CancellationToken cancellationToken = null)Rows of a table whose columns equal the given values (case-insensitive names).

ITabularSource interface

Minimal read contract every tabular backend implements: equality-filtered queries on one table. SQL databases (PPDM, Seabed, EDM via BeepDM IDataSource), CSV folders, REST gateways… all fit.

MemberSummary
Task<IReadOnlyList<DataRow>> QueryAsync(string table, IReadOnlyDictionary<string, object> equals, CancellationToken cancellationToken = null)Rows of table whose columns equal the given values (empty filter = all rows).

IWellDataProvider interface

Anything that can produce the library's canonical WellModel.

MemberSummary
string Name { get; }Provider name (usually the mapping profile or source system).
Task<IReadOnlyList<WellSummary>> FindWellsAsync(string nameContains = null, CancellationToken cancellationToken = null)Wells whose name contains nameContains (all wells when null).
Task<WellLoadResult> LoadWellAsync(string wellId, CancellationToken cancellationToken = null)Loads one well into the canonical model (problems become warnings).

JoinMap class

How a related table joins an entity's rows: on is a column of both tables, or "localColumn=relatedColumn".

MemberSummary
string On { get; set; }Join key: a column name present in both tables, or "localColumn=relatedColumn".

Las3Checker static class

Checks a LAS 3.0 file against the structure rules of the CWLS "LAS 3.0 File Structure Specifications" (Release 3.00, June 2000) - the checks LAS Certify 3.0 lists: ~Version / ~Well order and required lines, section titles, data / definition associations and channel counts, consistent delimiters, index and number formats, log data last with its parameter section, STRT / STOP / STEP against the log data, and association mnemonics. Returns the violations (empty = compliant).

MemberSummary
static List<string> Check(string text)The rule violations of a LAS 3.0 file's text.

LasLoadResult class

Result of reading a LAS file: the model, the log set, the LAS standard and any warnings.

MemberSummary
bool Decimated { get; set; }True when MaxSamples reduced the rows (envelope decimation).
string Encoding { get; set; }Encoding the file was read with (web name), when read from a file.
bool HasErrors { get; set; }True when no usable log data could be read.
LogSet Log { get; set; }The log set read (also added to Model.LogSets); null when the file had no usable data.
WellModel Model { get; set; }The model the LAS content was read into (the given one, or a new model).
long SourceRows { get; set; }Data rows with a valid index read from the file (before any depth window or decimation).
string Standard { get; set; }"LAS 2.0", "LAS 3.0"… from ~Version VERS.
List<string> Warnings { get; }Problems met while reading (never thrown).

LasReader static class

Reads LAS 2.0 / 3.0 into the canonical model: well header (WELL, UWI, COMP, FLD, SRVC… -&gt; header / extras) and one depth log set (index = DEPT / DEPTH / MD / TVD / TVDSS, else the first curve; NULL values -&gt; null). WRAP YES data is read as a token stream chunked by curve count (a row spans several lines); WRAP NO reads one row per line and tolerates short lines. LAS 3.0 ~Log_Definition / ~Log_Data sections are recognised (comma or space delimited). Never throws on malformed or hostile input: problems become warnings / HasErrors.

MemberSummary
static LasLoadResult Load(string text, WellModel into = null, string name = null)Reads LAS text (never throws; problems become warnings / HasErrors).
static LasLoadResult LoadFile(string path, WellModel into = null, LasReadOptions options = null)Reads a LAS file streaming (the text is never held in memory as a whole).
static LasLoadResult LoadFrom(TextReader reader, WellModel into = null, string name = null, LasReadOptions options = null)Reads LAS from a reader, streaming data rows (large files, network streams); never throws on malformed input.

LasReadOptions class

Options for reading large LAS files: curve selection, depth window, bounded envelope decimation.

MemberSummary
double? Bottom { get; set; }Keep rows with index at or above this value (index unit); null = no limit.
IReadOnlyCollection<string> Curves { get; set; }Curves to keep (mnemonics); null = all. The index curve is always kept.
string Encoding { get; set; }Encoding of the file (for example windows-1251); null = detect (BOM, valid UTF-8, else files.legacyEncoding).
int? MaxSamples { get; set; }Bound the rows kept: consecutive depth buckets become two rows holding each curve's minimum and maximum (spikes survive), merged pairwise as the file grows, so memory stays bounded without knowing the file length. Null = full resolution (use full resolution for analysis; decimation is for display and overview).
double? Top { get; set; }Keep rows with index at or below / above these values (index unit); null = no limit.

LasWriteOptions class

Options for writing LAS: version, null value, decimals.

MemberSummary
int? Decimals { get; set; }Decimals for values; null = round-trip precision.
double? NullValue { get; set; }Null value written for missing samples; null = environment loaders.lasDefaultNull.
string Version { get; set; }"2.0" (space delimited) or "3.0" (comma delimited, ~Log_Definition / ~Log_Data).

LasWriter static class

Writes a depth log set (and the well header) as LAS 2.0 or 3.0; read back by LasReader without loss.

MemberSummary
static string Write(WellModel model, LogSet set = null, LasWriteOptions options = null)Writes a depth log set (the model's first depth log set when null) with the well header as LAS text.

MappedWellDataProvider class

Generic adapter: reads any tabular source through a MappingProfile into the canonical WellModel. Handles unit columns / defaults, code translation, vertical property tables, provenance and preservation of unmapped columns. Problems become warnings, never silent drops.

Inherits / implements: IWellDataProvider

MemberSummary
MappedWellDataProvider(ITabularSource source, MappingProfile profile)A provider reading source through profile.
string Name { get; }Profile name.
MappingProfile Profile { get; }The mapping profile in use.
Task<IReadOnlyList<WellSummary>> FindWellsAsync(string nameContains = null, CancellationToken cancellationToken = null)Wells from the profile's well table whose name contains nameContains (all when null).
Task<WellLoadResult> LoadWellAsync(string wellId, CancellationToken cancellationToken = null)Loads a well: header, wellbores, hole sections, strings, components, intervals, tops and survey through the profile.
Task<IReadOnlyList<CodeObservation>> ObserveAsync(string wellId, CancellationToken cancellationToken = null)The code values this source holds for a well - raw and as resolved by the profile, the source vocabulary and the environment vocabulary (top names through the lexicons) - and every unit value; for coverage reports (DataCoverage).

MappingProfile class

Data-driven mapping from a source schema to the canonical WellModel. New source systems or schema versions = new profile JSON, no code. Entities: well, wellbore, holeSection, string, component, interval, top, survey.

Inherits / implements: IJsonPersistable

MemberSummary
string BaseDirectory { get; set; }Folder of the profile file (resolves relative vocabulary / lexicon paths); null for built-ins.
static IEnumerable<string> BuiltInNames { get; }Names of the profiles built into the library.
bool CaptureExtras { get; set; }Keep unmapped columns in Extra.
Dictionary<string, EntityMap> Entities { get; set; }Entity maps by canonical entity name (well, string, component...).
List<string> LexiconFiles { get; set; }Stratigraphic lexicon files for this source (relative to the profile file), checked before the environment's.
string Name { get; set; }Profile name (for example csv, ppdm39).
string Notes { get; set; }Notes (source system, assumptions, what to verify).
string System { get; set; }Recorded in every System.
bool Verify { get; set; }True when column names are unverified and must be checked against the target schema.
string Version { get; set; }Profile version.
Dictionary<string, Dictionary<string, string>> Vocabulary { get; set; }Inline vocabulary for this source (domain -&gt; source code -&gt; canonical), checked after per-field "codes" and before the environment's.
List<string> VocabularyFiles { get; set; }Vocabulary files for this source (relative to the profile file).
static IReadOnlyDictionary<string, string[]> CanonicalFieldsThe canonical fields of each entity, used to check profiles.
List<IStratigraphicLexicon> BuildLexicons(List<string> warnings = null)This profile's lexicons.
ICodeVocabulary BuildVocabulary(List<string> warnings = null)This profile's vocabulary: inline entries and files, in that order.
static MappingProfile FromJson(string json)Reads a profile from JSON.
static MappingProfile Load(string name)A profile by name: <name>.profile.json in the environment's resources.mappingProfilesFolder when present (customer / country variants, e.g. a company's PPDM), else the built-in profile.
static MappingProfile LoadBuiltIn(string name)Built-in profiles: "csv" (complete), "ppdm39" (starter — verify columns), "template".
static MappingProfile LoadFromFile(string path)Reads a profile file.
string ToJson()The profile as JSON (same format String) reads).
IReadOnlyList<string> Validate()Structural problems: unknown entities/fields, unknown default units, missing tables/well columns.

OsduExport static class

OSDU records of a well, per the OSDU data definitions (master-data--Wellbore 1.5.1, work-product-component--WellboreTrajectory 1.4.0, work-product-component--WellLog 1.5.0): ids and references in the data partition's namespace, depths in metres, curve units as UnitOfMeasure references (percent-encoded), acl / legal from the environment's osdu section.

MemberSummary
const string TrajectoryKind = "osdu:wks:work-product-component--WellboreTrajectory:1.4.0"Kind of the trajectory records.
const string WellboreKind = "osdu:wks:master-data--Wellbore:1.5.1"Kind of the Wellbore records.
const string WellLogKind = "osdu:wks:work-product-component--WellLog:1.5.0"Kind of the log records.
static List<JsonObject> Records(WellModel model, List<string> warnings = null)The records of a well: its Wellbore, its trajectory (with a survey) and one WellLog per depth log set.
static string ToJson(IEnumerable<JsonObject> records)The records as an indented JSON array.

PaySummaryExport static class

Pay summary exports.

MemberSummary
static string[] HeaderHeader of the exported table.
static void ToXlsx(PaySummaryResult r, Stream output)The pay summary as an Excel workbook (numbers stay numbers).

PropertyTableMap class

PPDM-style vertical property table (property type / value rows) feeding canonical attributes.

MemberSummary
string JoinColumn { get; set; }Column in the property table that joins to the parent record.
Dictionary<string, string> Map { get; set; }Property name in the source -&gt; canonical field; unmapped names go to Extra.
string NameColumn { get; set; }Column with the property name.
string ParentColumn { get; set; }Column of the PARENT row whose value is used for the join.
string Table { get; set; }Table holding the property rows (one row per property).
string UomColumn { get; set; }Column with the unit of the value, when the table has one.
string ValueColumn { get; set; }Column with the value.

QcIssue class

One issue found in a well.

MemberSummary
QcIssue(string severity, string code, string message)Creates an issue.
string Code { get; }Issue code (QC001, WV013, WS050, LOAD ...).
string Message { get; }Message.
string Severity { get; }Error, Warning or Info.

QcIssueGroup class

One issue code across the field.

MemberSummary
string Code { get; set; }Code.
int Count { get; set; }Occurrences.
string ExampleMessage { get; set; }An example message.
List<string> ExampleWells { get; }Up to three example wells.
string Severity { get; set; }Severity.

TabularTable class

A table produced by TabularWriter: name, column order and rows.

MemberSummary
List<string> Columns { get; }Column order.
string Name { get; set; }Table name (the CSV file name without extension).
List<Dictionary<string, string>> Rows { get; }Rows (column name to text).

TabularWriter static class

Writes a WellModel through a mapping profile - the exact reverse of MappedWellDataProvider: the profile's tables and columns, unit columns, per-field code maps (canonical -&gt; source code) and captured extra columns. A customer layout (another profile) is written in that layout. Values sharing a unit column are converted to one unit.

MemberSummary
static List<TabularTable> ToTables(WellModel model, MappingProfile profile = null, List<string> warnings = null)The model as tables for profile (default: the environment's "csv" profile).
static void WriteCsvFolder(WellModel model, string folder, MappingProfile profile = null, List<string> warnings = null)Writes the tables as RFC 4180 CSV files (one per table) into folder.

WellLoadResult class

Result of loading a well from a data source: the canonical model and any mapping warnings.

MemberSummary
WellLoadResult(WellModel model, IReadOnlyList<string> warnings)Creates a result: the loaded model and the warnings.
WellModel Model { get; }The loaded well.
IReadOnlyList<string> Warnings { get; }Unknown units, untranslated codes, missing tables… (never silently dropped).

WellQcRow class

What one well has, and how many issues it raised.

MemberSummary
bool Datum { get; set; }Has an elevation for its depth datum.
int Errors { get; set; }Errors raised.
bool Header { get; set; }Has a header with a name.
bool Logs { get; set; }Has logs.
string Name { get; set; }Well name.
bool Position { get; set; }Has a wellhead latitude / longitude.
bool Pressures { get; set; }Has pressure tests.
int Score { get; }Ranking: errors weigh most, then warnings, then missing items.
bool Survey { get; set; }Has a survey (2+ stations).
bool Tops { get; set; }Has formation tops.
bool Tubulars { get; set; }Has casing / tubing strings.
int Warnings { get; set; }Warnings raised.
string WellId { get; set; }Well id in the source.

WellSummary class

A well listed by a data source (id and name) before it is loaded.

MemberSummary
string Field { get; set; }Field.
string Id { get; set; }Well id in the source.
string Name { get; set; }Well name.
string Uwi { get; set; }Unique well identifier (UWI / API), when known.

Witsml21Export static class

WITSML 2.1 data objects of a well (Energistics WITSML v2.1 / common v2.3 schemas): Well, Wellbore, Trajectory (with stations), and per depth log set a Log whose ChannelSet holds the Channels and references its bulk data by FileUri - a LAS 3.0 file written alongside (the schema's business rule: Data or FileUri; the inline JSON layout is not specified, so it is not used). Channels reference their property kind from the Energistics property kind dictionary (v2.3) and a BusinessAssociate (the logging company). UUIDs are name-based (stable across exports).

MemberSummary
static IReadOnlyDictionary<string, (string, string)> PropertyKinds { get; }Energistics PropertyKind dictionary v2.3 entries used for channels (title, uuid) - checked against the dictionary in CI.
static IReadOnlyList<ExportFile> Export(WellModel model, List<string> warnings = null)The WITSML 2.1 files of a well (XML objects and the LAS 3.0 files their channel sets reference).

WitsmlGrowingLogSource class

Growing-log source over a WITSML store: the constructor's query delegate performs the transport call (e.g. WMLS_GetFromStore / ETP with a startIndex) and returns the WITSML logs XML; only rows strictly after the last index are returned, so a store that ignores startIndex, or re-sends overlapping rows, is handled. Depth-indexed logs only.

Inherits / implements: IGrowingLogSource

MemberSummary
WitsmlGrowingLogSource(Func<double?, CancellationToken, Task<string>> query)A growing-log source over a WITSML query: query returns the log XML with rows after the given index (all when null).
IReadOnlyList<string> LastWarnings { get; }Warnings from the last response (time-indexed logs, bad rows…).
Task<GrowingLogRows> FetchAfterAsync(double? lastIndex, CancellationToken cancellationToken = null)Queries the store and returns the new rows (duplicates and rows not after lastIndex are dropped).
static WitsmlGrowingLogSource FromStore(WitsmlStoreClient client, WitsmlLogReference log)A growing-log source over a WITSML 1.4.1.1 store: each fetch asks for the log's data after the last index received (returnElements=data-only), so polling resumes where it stopped after a disconnect.

WitsmlLoadResult class

Result of reading WITSML documents: the model, counts of stations, markers and logs, and warnings.

MemberSummary
int Logs { get; set; }Number of logs read.
int Markers { get; set; }Number of formation markers read.
WellModel Model { get; set; }The model the WITSML content was read into.
int Stations { get; set; }Number of trajectory stations read.
List<string> Warnings { get; }Problems met while reading.

WitsmlLogReference class

The log a growing-log source follows.

MemberSummary
string IndexUnit { get; set; }Unit of the depth index (m, ft); default units.depthUnit.
string UidLog { get; set; }Log uid.
string UidWell { get; set; }Well uid.
string UidWellbore { get; set; }Wellbore uid.

WitsmlQueries static class

WITSML 1.4.1.1 queries.

MemberSummary
const string Namespace = "http://www.witsml.org/schemas/1series"WITSML 1.4.1.1 data object namespace.
static string LogDataAfter(WitsmlLogReference log, double? startIndex)Query for the data of a depth log after startIndex (all data when null).

WitsmlReader static class

Reads WITSML trajectories, formation markers and logs into the canonical model. Elements are matched by local name, case-insensitively, so WITSML 1.3.1.1 / 1.4.1.1 (lowercase, "1series" namespace) and 2.0 (PascalCase) trajectories read alike. Units come from each value's uom: angles in dega / deg / rad (public field data often uses rad), lengths in any known unit including the US survey foot "ft[US]" (converted exactly, 1200/3937 m). Depth-indexed logs only; time-indexed logs are reported, not mis-read.

MemberSummary
static WitsmlLoadResult Load(string xml, WellModel into = null)Reads WITSML XML text.
static WitsmlLoadResult Load(IEnumerable<XDocument> docs, WellModel into = null, string entity = null)Reads WITSML documents (1.3.1.1, 1.4.1.1 or 2.0: trajectories, formation markers, logs) into a model.
static WitsmlLoadResult LoadFile(string path, WellModel into = null)Reads a WITSML file.

WitsmlStoreClient class

Client for a WITSML 1.4.1.1 store over SOAP 1.1 (WMLS_GetVersion, WMLS_GetFromStore): basic authentication (https required unless allowed), timeout, retries with doubling delay for transient failures only (network errors, timeouts, HTTP 5xx without a SOAP fault); SOAP faults and negative WITSML results are raised as WitsmlStoreException. Message namespace and SOAPAction prefix follow the standard WSDL and can be changed for stores that differ.

MemberSummary
WitsmlStoreClient(WitsmlStoreOptions options, HttpMessageHandler handler = null)A client for options; handler replaces the HTTP handler (tests, proxies).
int RequestCount { get; }Number of HTTP requests sent (retries included).
void Dispose()Releases the HTTP client.
Task<WitsmlStoreResult> GetFromStoreAsync(string wmlType, string queryXml, string optionsIn = null, CancellationToken cancellationToken = null)Reads data objects (WMLS_GetFromStore); throws WitsmlStoreException for a negative result.
Task<string> GetVersionAsync(CancellationToken cancellationToken = null)Data schema versions the store supports (WMLS_GetVersion), for a connection check.

WitsmlStoreException class

A store call that failed: SOAP fault, WITSML error result, HTTP error or retries exhausted.

Inherits / implements: Exception

MemberSummary
WitsmlStoreException(string message, Int16? resultCode = null, HttpStatusCode? status = null, Exception inner = null)Creates the exception with the WITSML result code and HTTP status when known.
Int16? ResultCode { get; }WITSML result code, when the store returned one.
HttpStatusCode? Status { get; }HTTP status, when the failure was an HTTP error.

WitsmlStoreOptions class

Connection settings of a WITSML 1.4.1.1 store (SOAP).

MemberSummary
string ActionPrefix { get; set; }SOAPAction prefix; the method name is appended (standard WSDL: http://www.witsml.org/action/120/Store.).
bool AllowInsecureHttp { get; set; }Allow credentials over plain http (only for closed test networks).
Uri Endpoint { get; set; }Store endpoint (https) - required: there is no default server.
string MessageNamespace { get; set; }Namespace of the store's SOAP messages (standard WSDL: http://www.witsml.org/message/120).
string Password { get; set; }Password for basic authentication.
int Retries { get; set; }Retries after a transient failure (network error, timeout, HTTP 5xx without a SOAP fault) (default live.witsmlRetries).
TimeSpan RetryDelay { get; set; }Delay before the first retry; doubled for each further retry (default live.witsmlRetryDelaySeconds).
TimeSpan Timeout { get; set; }Time allowed for one request (default live.witsmlTimeoutSeconds).
string UserName { get; set; }User name for basic authentication (null = none).

WitsmlStoreResult class

The reply of a store method: WITSML result code (positive = success), returned XML and the server's message.

MemberSummary
string Message { get; set; }The server's message (SuppMsgOut).
Int16 Result { get; set; }WITSML result code: positive = success, negative = error.
bool Success { get; }True for a positive result code.
string XmlOut { get; set; }Returned XML (XMLout).

WitsmlWriter static class

Writes WITSML 1.4.1.1 trajectories, formation markers and depth logs ("1series" namespace), read back by WitsmlReader without loss. Fluid contacts have no field in a 1.4.1.1 formationMarker: they are written as markers with their names, the contact type is not carried.

MemberSummary
static string FormationMarkers(WellModel model)The formation tops as WITSML 1.4.1.1 formation markers.
static string Logs(WellModel model, double? nullValue = null)The depth log sets as WITSML 1.4.1.1 logs (missing samples written as nullValue, default the environment's LAS null).
static string Trajectory(WellModel model, string name = "Trajectory")The trajectory (survey stations) as a WITSML 1.4.1.1 document.

XlsxWriter static class

A minimal Excel (.xlsx, Office Open XML) writer: one sheet, numbers as numbers, text as inline strings - no dependencies.

MemberSummary
static void Write(Stream output, string sheetName, IReadOnlyList<string> header, IEnumerable<IReadOnlyList<object>> rows)Writes a sheet with a header row and data rows (double / int / null / text cells).