TheTechIdea OilGas - Developer guide User guide →

TheTechIdea.OilGas.Wellbore.Data

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

TheTechIdea.OilGas.Wellbore.Data

TypeSummary
AbandonmentRuleSetclassA named abandonment rule set. A template leaves values empty for your engineers to fill in from the regulation's current edition; checks that need an empty value are skipped and reported (WP008), never filled with another regime's numbers.
AbandonmentSettingsclassEnvironment section: permanent plug and abandonment checks. Defaults follow common NORSOK D-010 practice - verify against your standard's revision.
Annulistatic classAnnulus identification from casing strings reaching surface, and annulus helpers such as fluid fill colours.
AnnulusFluidenumWhat fills an annulus (drives the drawn colour).
AnnulusInfoclassOne surface-accessible annulus (A = tubing / production casing, B = production / next casing, …) with its fluid, pressure history and limits. MAASP / MAWOP are normally supplied by well-integrity engineering; see MaaspScreening for a transparent screening estimate.
AnnulusPressureReadingclassA recorded annulus pressure, compared against the annulus MAWOP and MAASP.
AnnulusSettingsclassEnvironment section: MAASP screening deratings.
AnnulusStatusenumAnnulus pressure status against its operating limits.
AntiCollisionstatic classAnti-collision per the ISCWSA separation rule (SPE-187073): closest approach of each offset well along the reference well, separation factor, MASD and allowable deviation from plan from the ISCWSA position uncertainty (pedal-curve projection along the centre-to-centre line). Wells are placed in a local east-north-up frame around the reference wellhead (WGS84), depths below mean sea level via each well's depth datum, azimuths to true north.
AntiCollisionResultclassResult of an anti-collision scan.
AntiCollisionSettingsclassEnvironment section: anti-collision (ISCWSA separation rule, SPE-187073, Sawaryn et al. 2019): SF = (D - Rref - Roff - Sm) / (k * sqrt(sigmaS^2 + sigmaPA^2)); MASD = k * sqrt(...) + Rref + Roff + Sm; ADP = D - MASD.
AttributeRuleclassA rule for one equipment attribute: what kind of value, its unit, whether it is required, allowed values or range.
AuditActionenumWhat an audit entry records.
AuditEntryclassOne audited change of a well: when, who, what (item and field), before and after, and why.
BarrierDocumentStatusenumBarrier planning / documentation state (must be stated on a WBS).
BarrierElementclassOne well barrier element (WBE).
BarrierElementStatusenumWell barrier element condition. Worst element status sets the envelope status.
BarrierEnvelopeclassOne well barrier envelope (primary, secondary or environmental) and its elements.
BarrierEvidencestatic classTurns cement bond evidence into status proposals for casing-cement barrier elements: Intact (verified) when the longest CONTINUOUS good-bond interval inside the element reaches the required isolation length, Impaired otherwise; Unverified when less than the minimum fraction of the element was logged (a log that barely touches an element cannot verify it); no proposal where it was not logged at all. Nothing changes until Boolean) is called.
BarrierIssueclassA barrier or annulus validation finding: code, severity, message and the element concerned.
BarrierIssueSeverityenumSeverity of a barrier or annulus validation finding.
BarrierRoleenumWhich barrier an envelope is (NORSOK D-010 colours: primary blue, secondary red, environmental green).
BarrierSettingsclassEnvironment section: barrier requirement, impaired-element rule and acceptance-criteria references.
BarrierStatusProposalclassA proposed barrier element status change with its reason — reviewed, then applied explicitly.
BarrierTargetKindenumWhat part of the well a barrier element refers to.
BarrierValidatorstatic classBarrier checks derived from NORSOK D-010 well barrier principles: two envelopes, common WBEs flagged for risk assessment, failed / impaired / unverified elements reported, references resolvable, casing and cement WBEs carrying size and depth. Target existence is checked through a caller-supplied resolver (source-agnostic).
BrandingSettingsclassEnvironment section: the trademark footnote (and optional logo) on exports, prints and views.
BuiltInToolModelsstatic classThe tool models embedded in this library (tool-models.json); environments add their own in survey.toolModels.
CasingCheckclassA string's ratings against the loads: design factors and whether each meets the minimum.
CasingDesignstatic classCasing design checks with the API Bulletin 5C3 / API TR 5C3 formulas behind the API 5CT / 5C2 tables: burst (Barlow, 87.5 % wall), collapse in four regimes by D/t (yield, plastic, transition, elastic; A, B, C, F, G rounded as API tabulates them) and pipe-body tension; rounding as API (10 psi, 1000 lbf).
CasingDesignFactorsclassMinimum design factors (rating / load).
CasingDesignSettingsclassEnvironment section: casing design checks (API TR 5C3 / API Bulletin 5C3 ratings).
CasingLoadCaseclassLoads of a simple design check.
CasingRatingclassAPI 5C3 ratings of one string (psi, lbf); null where the pipe could not be rated (see Notes).
CavityKindenumRole of a cavity in a leak-path network: the source (reservoir), an intermediate cavity or the sink (surroundings).
CementBondClassenumCement bond quality class used as barrier evidence.
CementBondEvidenceclassSource-neutral cement bond evidence (from a CBL/VDL, ultrasonic log…): one classified interval, document depth unit.
CementSettingsclassEnvironment section: CBL calibration, bond-index cutoffs and cement-barrier verification rules.
ChangeKindenumKind of difference between two well states: added, removed or modified.
ColorStopclassA colour at a position (0 to 1) in a palette.
ComponentTypeInfoclassOne canonical component type.
ComponentTypesstatic classCanonical component vocabulary. Source codes translate to these through mapping-profile code tables; renderers map these to symbols. Keep codes stable: they are persisted.
ConfigIssueclassA problem found in a configuration resource file (lexicon, vocabulary, labels, symbols), with a stable code.
ConfigIssueSeverityenumHow serious a problem in a configuration resource file is.
ConfigurationChecksstatic classCross-checks of the configured parts that only fail when used (CV001-CV006).
ConfigurationSaveReportclassWhat String) wrote, and the parts it could not save (host implementations that are not JSON).
ConfiguredFilesstatic classFiles an environment names (resources.lithologyFile, resources.symbolCatalogFile...): resolved against the environment's folder, read once per file version, and reported in the services' warnings when missing or broken - never silently replaced.
ContactIntervalclassPerforation / open interval / slotted section (PPDM "Wellbore Contact Interval").
ContactTypeInfoclassA fluid contact type: code, name, drawing colour, rank from the top and limit direction.
ConversionSettingsclassEnvironment section: defaults for converting a well model into schematic and wellbore views.
CoreSampleclassOne core-plug measurement set at a depth (driller's core depth; see CoreShift).
CoreShiftclassCore-to-log depth shift for one core (added to core depths).
CorrelationSettingsclassEnvironment section: correlation panel defaults.
CountryPresetsstatic classReady-made country environments through the current services' country catalog (ICountryCatalog, default: the 62 built-in countries generated by tools/countries). Use "extends": "country:RU" and override anything in your file.
CrossplotSettingsclassEnvironment section: crossplots (density-neutron lithology lines, Pickett saturation lines, point style).
CrossSectionSettingsclassEnvironment section: cross-section defaults.
CurveDepthShiftclassA recorded depth correction of one curve (auditable: who, when, why). One tie point is a bulk shift; several tie points match depths piecewise-linearly between them and shift by the end offsets beyond the first / last point.
CurveFamilyRuleclassA log curve family (track) and the mnemonics that belong to it.
CurvePresentationclassResolved presentation of a log curve.
CurveStyleRuleclassPresentation (colour, scale, fill, brush, line width) for the curves matching a rule.
CurveValueCheckclassA curve value a "dataSource" verification case expects: the curve (in a named log set, or any), the index and the value.
CuttingsSampleclassCuttings description over a sample interval: lithology percentages (shared lithology codes).
DataSourceDefinitionclassA company data source named in the environment: what it is (kind), where (path, relative to the environment file), the mapping profile it is read with, and the company's own overrides over that profile (code values, row filters). Open it with the loaders library's DataSources; check it with a "dataSource" verification case.
DatumElevationclassElevation of a depth datum (KB, RT, DF, GL...) above its reference, usually mean sea level.
DepthPathenumDepth path.
DepthTiePointclassA depth-matching tie point: the logged depth From belongs at To.
DimensionenumUnit dimensions known to the registry.
DipAzimuthReferenceenumWhat a dip azimuth is measured from.
DipConversionstatic classDip geometry between the earth and the borehole. Frames (north / east / down): the hole axis t = (sin I cos A, sin I sin A, cos I), its high side h = (cos I cos A, cos I sin A, -sin I) and r = t x h (clockwise from h looking down-hole). A bed of dip d toward azimuth a has the upward normal n = (sin d cos a, sin d sin a, -cos d); relative to the hole n = sin d' (cos a' h + sin a' r) - cos d' t. The dip azimuth is the direction of the deepest point of the bed's sinusoid on an image.
DipFrameenumWhat a dip angle is measured against.
DipMeasurementclassA structural dip pick: angle and azimuth of the dip direction (the deepest point of its sinusoid). By default a true (geographic) dip with its azimuth from north; Frame, AzimuthReference and NorthReference say otherwise (null: the environment's dips section). String}) turns any pick into a true dip in the working north.
DipSettingsclassConventions of dip picks that do not state their own.
DipTypeenumKind of planar feature a dip pick represents (bedding, fracture, fault...).
DisplayFormatstatic classNumbers and dates as they appear on screen and in printed output, by the environment's locale section. Files (CSV, LAS, WITSML, JSON) never use it: they stay invariant whatever the locale or the machine's culture.
DisplaySettingsclassEnvironment section: display defaults (track gap, header height, depth scale).
EngineeringAttributesclassEngineering attributes shared by strings and components (tally, barrier and sizing input).
EnvironmentReportstatic classEffective settings of an environment as flat rows (path, value, source) and differences between environments.
EquipmentIssueclassA problem with an equipment attribute (codes WE001-WE005).
EquipmentIssueSeverityenumSeverity of an equipment attribute issue.
EquipmentRulesstatic classEquipment attributes by rule (environment equipment.attributes): the rules of a component type, values by key (built-in typed fields or company keys in Extra), display text, and validation.
EquipmentSettingsclassEnvironment section: equipment attribute rules by component type and the completion tally columns.
ErrorFormulaclassA weighting-function formula as the ISCWSA / OWSG error models write them ("Sin(AzT) / (EarthRate * Cos(Latitude) * Cos(Inc))"): numbers, variables (case-insensitive), + - * / ^, unary minus, parentheses and the functions Sin, Cos, Tan, Abs, Sqr / Sqrt, Max, Min. An unknown variable or function is an error, never a silent zero.
ErrorSourceclassOne survey error source (ISCWSA structure): its size, how it affects a station (weight) and how it propagates between stations (random: independent per station; systematic: the same along a survey; global: the same everywhere).
FieldChangeclassOne field that differs between two versions of the same item: field name, old value and new value.
FilesSettingsclassEnvironment section: reading text files from anywhere.
FixedClockclassA clock that always reads the same time (or advances by a fixed step on every read), for deterministic runs.
FluidTypeenumFormation fluid typed from its pressure gradient.
FormationTopclassA formation top or fluid-contact pick at a measured depth, with its canonical stratigraphic unit when known.
FreeFluidLevelclassIntersection of two gradient lines — a free-fluid level (not a log contact: capillary transition lies above it).
GasCharacterenumFluid character interpreted from mud-gas ratios (Haworth et al. 1985).
GasRatiosstatic classHaworth, Sellens & Whittaker (1985, AAPG Bulletin 69(8)) light-gas ratios and a SCREENING fluid interpretation: Wh = (C2+C3+C4+C5)/(C1..C5) x 100, Bh = (C1+C2)/(C3+C4+C5), Ch = (C4+C5)/C3. Wh 0.5-17.5 gas (Ch < 0.5 confirms gas, > 0.5 gas associated with oil), 17.5-40 oil, > 40 residual oil, < 0.5 very dry gas. Ratios are meaningful only in a show: readings with total gas below minShowGas are Background.
GasRatioSettingsclassEnvironment section: Haworth ratio bands and the show-gas threshold.
GasReadingclassOne mud-gas chromatograph reading: total gas and C1-C5 (ppm).
GradientFitclassA fitted pressure gradient: p = Intercept + Gradient x TVD (psi, TVD in the analysis unit).
GrowingLogRowsclassNew rows of a growing log (index in IndexUnit; values aligned with Mnemonics).
GuidIdGeneratorclassRandom ids (32 hex digits).
HistorySettingsclassEnvironment section: tolerances for matching items between well states.
HoleSectionclassA drilled hole section: depth range and bit size.
IClockinterfaceContract: the current time. Default: the system clock; FixedClock for deterministic runs.
ICodeVocabularyinterfaceTranslates source-system codes (PPDM, Seabed, a company database, a vendor file…) to canonical codes.
ICountryCataloginterfaceContract: the ready-made country environments a host offers ("extends": "country:XX").
ICurveClassifierinterfaceLog curve family (track), order and style from its mnemonic.
IGrowingLogSourceinterfaceA source of rows appended to a log while drilling (WITSML "growing object" semantics): returns the rows after lastIndex (null = from the start). Implementations wrap a transport (WITSML store SOAP / ETP, file tail…).
IIdGeneratorinterfaceContract: new record ids. Default: random GUIDs; SequentialIdGenerator for deterministic runs (tests, lockstep hosts).
IJsonPersistableinterfaceA configurable part that saves itself as JSON; its type reads the same JSON back (FromJson). Load -> save -> load gives the same part (tested for every part).
ILabelProviderinterfaceUI texts per culture / company.
ILeakPathTemplatesinterfaceContract: the leak-path networks a host offers and how they are chosen for a barrier set.
ImageLogSettingsclassEnvironment section: borehole-image normalization and colour levels.
IModelCataloginterfaceContract: the vocabulary of the well model - component types, barrier element types, fluid contact types.
IscwsaErrorModelstatic classISCWSA / OWSG survey error model (the formulation of SPE 67616 with the Rev 5 terms): each term's weighting function gives its effect on depth, inclination and azimuth; position derivatives turn that into north / east / vertical errors, summed as random, systematic or global terms.
IStratigraphicLexiconinterfaceMaps layer names that differ by company or country to canonical units.
ISymbolResolverinterfaceCanonical component type -> schematic symbol id.
ItemStatusenumLifecycle state of an installed item.
IUnitCataloginterfaceContract: the units a host knows (symbols and aliases). Units converts through the current services' catalog.
JsonCodeVocabularyclassJSON vocabulary: { "name": "...", "domains": { "componentType": { "PKR": "PACKER_PERMANENT" }, ... } } (case-insensitive).
JsonCountryCatalogclassCountry catalog held as JSON documents by code; the built-in one holds the 62 embedded country files. Loads and saves as one JSON map.
JsonLabelProviderclassJSON labels: { "culture": "nb-NO", "labels": { "track.depth": "Dybde" } }; unknown keys return the fallback.
JsonLeakPathTemplatesclassLeak-path networks held as JSON: { "networks": { name: definition }, "selection": [ rules ], "default": name }. The built-in file is embedded (leak-path-networks.json); companies merge their own by network name (resources.leakPathFiles).
JsonModelCatalogclassModel catalog held as JSON: { "componentTypes": [...], "barrierElementTypes": [...], "contactTypes": [...] }. The built-in one is embedded (model-catalog.json); companies merge their own files over it by code (resources.modelCatalogFiles).
JsonStratigraphicLexiconclassJSON lexicon: { "name", "stripPrefixes": ["Top ", "Base "], "units": [ { "id", "name", "aliases", "localNames", "lithology", "color" } ] }.
JsonSymbolResolverclasscomponent-symbols JSON: { "types": { "PACKER_PERMANENT": "pk_permanent", ... } }; null for unmapped types (callers fall back).
JsonUnitCatalogclassUnit catalog from unit definitions (environment units.definitions); loads and saves the definitions as JSON.
LayeredLabelsclassFirst provider that has a label wins.
LayeredLexiconclassFirst lexicon that resolves a name wins.
LayeredVocabularyclassFirst vocabulary that maps a code wins (data source first, then environment files).
LeakCavityclassA pressure-containing volume in the well (reservoir, tubing bore, annulus…) or the surroundings.
LeakChainDefinitionclassA chain network (permanent abandonment): source, one bore cavity between consecutive envelopes, sink; every element of an envelope links its two cavities.
LeakEdgeclassA connection between two cavities: a barrier element (by id in the barrier set) or an open connection (no element). Undirected: a leak can cross it either way.
LeakLinkDefinitionclassA link of a leak-path network: every barrier element of Type (in envelope Role, or any) joins cavity A to cavity B.
LeakNetworkDefinitionclassA named leak-path network: fixed cavities and edges plus links to barrier elements, or a chain; may be based on another network.
LeakNetworkSelectionclassChooses a network for a barrier set: the first rule whose words appear in the set's phase or well type.
LeakPathclassOne path from the reservoir to the surroundings through the leak-path network, with the barriers still holding on it.
LeakPathAnalysisstatic classCounts, for every simple path from the source (reservoir) to the sink (surroundings), the barrier elements that still hold. Intact and Unverified count (unverified flagged); Impaired counts only if countImpaired; Failed never. The well meets an N-barrier requirement when the weakest path still has N.
LeakPathNetworkclassLeak-path network (a well barrier diagram): cavities joined by barrier elements.
LeakPathResultclassResult of a leak-path analysis: every path, the weakest barrier count and whether the requirement is met.
LithologyLineclassA density-neutron lithology line: from the matrix point (neutron reading at zero porosity, matrix density) to the fluid point.
LiveSettingsclassEnvironment section: real-time display (stale threshold, follow span).
LoaderSettingsclassEnvironment section: file loader defaults (LAS index mnemonics, null value).
LocaleSettingsclassHow numbers and dates look on screen and in printed output; files always stay invariant.
LogCurveDataclassOne curve of a log set: values aligned with the set's index (null = no data).
LogEditingstatic classDepth shifting and splicing of log sets - non-destructive: results are new sets, the inputs stay as they are.
LogEditSessionclassLog edits on a well model with an audit entry for each and undo: an undo restores the previous log set object exactly.
LogIndexTypeenumWhether a log set is indexed by depth or by time.
LogSetclassCanonical, format-neutral log data (from WITSML, LAS, DLIS…): an index (depth in IndexUnit, or time) and curves. Presentation families build tracks from it; loaders fill it.
LogSettingsclassEnvironment section: log curve families, styles and log validation thresholds.
MaaspLimitclassOne limiting pressure in a MAASP screening.
MaaspScreeningstatic classMAASP SCREENING estimate (not a design calculation). Surface-point simplifications: outer casing burst x derating, inner string collapse x derating, formation at the outer shoe = (fracture gradient − annulus fluid gradient) x shoe TVD, wellhead / hanger rating. The lowest limit governs. ISO 16530-1 and API RP 90 require a full analysis (depth-dependent loads, backup fluids, temperature, wear); use this to flag, not to set, limits.
MagneticFieldValuesclassMagnetic field at a place and time.
MagneticReferencestatic classThe field and reference values of a well for its survey error model: the header's values, else the geomagnetic model at the well.
MapSettingsclassEnvironment section: well map (plan view) colours and grid.
MeasureclassA value with a unit, as written in environment files: { "value": 10, "unit": "ft" }.
MnemonicMatchclassPattern test on a curve mnemonic (case-insensitive); any listed condition matching is a match.
ModelAuditstatic classThe audit trail of a well (Audit): record changes between two versions of a model, log single changes, query the history of an item or a time range, export as CSV. Entries are appended, never rewritten.
ModelCatalogstatic classThe model catalog in effect: the current services' (ModelCatalog), else the built-in one.
ModelIssueclassA finding about a well model (code, severity, message, the record concerned).
ModelIssueSeverityenumSeverity of a model issue.
NorthCorrectionstatic classCorrects survey azimuths from the well's survey north (magnetic / true / grid) to the environment's working north: magnetic to true adds the declination; true to grid subtracts the convergence (east-positive convention, configurable). A correction that needs a missing value is reported and left out, never guessed.
NorthReferenceenumNorth a direction refers to.
NullContractsstatic classNull objects: never break a view when a contract is not configured.
OffsetSeparationclassThe scan of one offset well.
OsduSettingsclassEnvironment section: OSDU export - the data partition and the access / legal metadata every OSDU record needs (deployment-specific; no defaults).
PaperDefinitionclassA paper size in points (1/72 inch), portrait.
PayCutoffsclassPay cutoffs: a sample is net reservoir when Vsh <= vshMax and porosity >= porosityMin, net pay when also Sw <= swMax (unset = not applied).
PaySummarystatic classPay summary (gross, net reservoir, net pay, averages) per zone between formation tops, with the cutoffs of petrophysics.cutoffs / zoneCutoffs. Sample thickness: half the distance to each neighbour, clipped to the zone.
PaySummaryResultclassPay summary of a log set over the well's zones.
PayZoneclassPay summary of one zone (between two formation tops); thicknesses in the log index unit.
Petrophysicsstatic classTextbook petrophysical relations (pure functions). Shale volume from the gamma-ray index (linear, Larionov tertiary / older, Clavier, Steiber); density porosity; density-neutron combination (average or root mean square); Archie water saturation and bulk volume water. Archie assumes clean formations: no shale correction (Simandoux, Indonesia) is applied.
PetrophysicsCalculatorstatic classComputes VSH, PHID, PHIT, SW and BVW for a depth log set with the environment's petrophysics settings. Inputs are found by mnemonic through the curve-mnemonic vocabulary; missing inputs skip only the curves that need them (reported). Output values are null where an input is null.
PetrophysicsSettingsclassEnvironment section: parameters of the computed petrophysical curves (shale volume, porosity, Archie saturation).
PipeDimensionclassA pipe dimension: nominal weight -> wall thickness for one outside diameter (inches, lb/ft).
PressureAnalysisstatic classPressure-depth analysis: least-squares gradients per zone (explicit labels, or optimal automatic segmentation into up to maxZones straight segments), fluid typing from the gradient, and free-fluid levels at line intersections. Typical gradient ranges (psi/ft): gas < 0.20, oil 0.20-0.40, water >= 0.40 — screening, not a PVT substitute.
PressureAnalysisResultclassResult of a formation-pressure analysis: gradient fits per zone, fluid types and free-fluid levels.
PressureQualityenumFormation tester result quality; only Valid tests enter gradient analysis.
PressureSettingsclassEnvironment section: fluid-typing boundaries, automatic zoning and fit-quality thresholds.
PressureTestclassOne wireline formation pressure test (RFT / MDT / XPT-type).
PrintSettingsclassEnvironment section: paper, scale, header block, legend, footer, page templates and raster resolution.
PrintTemplateclassA named page template: every setting is optional and overrides the printing defaults only when set.
QuantityclassA measured value with its unit of measure. The original unit is kept; convert on demand.
ReferenceCaseclassA known-answer case run by wellbore-config verify: a calculation with its expected result and tolerance. Kinds: unit, trajectory, north, uncertainty (built in); other libraries add kinds (dipSinusoid). Only the fields of the case's kind are used.
ReferenceCaseResultclassResult of a reference case: pass / fail with each compared value.
ReferenceCasesstatic classRuns reference cases with the current services (units, north, error model of the environment in scope).
RegionSettingsclassEnvironment section: the country or region the environment is for (set by a country preset).
ResourceSettingsclassExternal files overriding built-in resources; paths relative to the environment file.
RoleDefinitionclassWhich items play a role: by component type, by symbol id, by symbol id prefix; excluded symbols never match by symbol.
RowclassOne effective setting: dotted path, JSON value and where it came from (file, preset or "default").
RuleCurveClassifierclassClassifies curves with the environment's family and style rules (data-driven; no code per mnemonic).
SchemaMigrationsstatic classShared JSON schema-version handling for every library document.
SchematicSettingsclassEnvironment section: schematic layout geometry.
SeparationLevelclassA separation-factor level: separation below Below triggers it (most severe = lowest).
SeparationPointclassSeparation between the reference well at one depth and the closest point of an offset well (metres).
SequentialIdGeneratorclassDeterministic ids: prefix + a counter (thread-safe), for example id000001, id000002...
SourceRefclassWhere a record came from (PPDM keeps SOURCE in version keys; every canonical record keeps this).
SpliceOptionsclassOptions of a splice.
SpliceRuleenumWhich run's data a splice keeps where runs overlap.
StandardLexiconsstatic classPublished stratigraphic standards built into the library, layered under a company's own lexicons (resources.standardLexicons): ICS - the International Chronostratigraphic Chart v2020/01 (178 units: ranks, hierarchy, boundary ages, CGMW colours, names in 20 languages).
StationCovarianceclassPosition covariance at a station (north, east, vertical), in the survey's length unit squared.
StationUncertaintyclassPosition uncertainty at a survey station: covariance (north, east, vertical) and ellipses.
StratigraphicUnitclassA canonical stratigraphic unit (formation / layer) with its local names.
StratigraphyQueriesstatic classHierarchy and ages of stratigraphic units across lexicon layers (a company formation's parent can be a chart unit).
StringKindenumKind of tubular string.
StyleSettingsclassEnvironment section: domain colours (barriers, contacts, dips, fluids, statuses, palettes).
SurveyErrorContextclassThe field and reference values the sensor terms need for a well.
SurveyLegclassA leg of the survey program in the view's survey unit.
SurveyProgramLegclassOne leg of a survey program: the tool (error model) that surveyed from a depth.
SurveyProgramsstatic classThe survey program a well's data gives.
SurveySettingsclassEnvironment section: survey quality control.
SurveyStationclassA directional survey station: measured depth, inclination, azimuth and optional TVD.
SurveyUncertaintystatic classSurvey position uncertainty in the ISCWSA structure: each error source has a size, a weighting function (its effect on MD, inclination or azimuth at a station) and a propagation mode; error derivatives use balanced-tangential station geometry; random errors add as independent covariances, systematic and global errors add as correlated vectors. The default sources are a simplified MWD subset (environment survey.uncertainty) - replace them with your tool model's values.
SymbolRolesstatic classSymbol roles in effect (environment schematic.roles): does an item play a role in the logic?
SystemClockclassThe system clock.
TallyColumnSpecclassA column of the completion tally.
TextEncodingsstatic classText file encodings for files from anywhere: a byte-order mark wins; otherwise strictly valid UTF-8 is read as UTF-8 (legacy text is practically never valid UTF-8 by accident); otherwise the legacy code page given, else the environment's files.legacyEncoding (windows-1251 / cp866 Cyrillic, gbk Chinese, shift_jis Japanese, windows-1256 Arabic...).
ThemeSettingsclassEnvironment section: theme colours, fonts and line widths shared by all views.
ToolboxRegistrationclassA registered toolbox: its name in the environment's "toolboxes" section, its settings type and validator.
ToolboxRegistrystatic classToolboxes - libraries on top of the core (well integrity, drilling, production, data and AI, training) - register their settings here; the environment then carries them under "toolboxes", validates them and lists them in the template and schema.
ToolErrorModelclassA survey tool error model: its terms and parameters (for example ISCWSA MWD Rev 5).
ToolErrorResultclassResult of an ISCWSA error model computation: totals and each term, per station.
ToolErrorTermclassOne error term of a survey tool model (an OWSG / ISCWSA error code).
TrajectoryclassWell path by the minimum curvature method (industry standard): each survey interval is a circular arc; TVD, northing and easting use the ratio factor RF = 2/β·tan(β/2). Interpolation between stations follows the same arc (not linear). MD, TVD, N and E share Unit.
TrajectoryStationclassA computed trajectory point (angles in degrees, lengths in the trajectory unit).
TubularCatalogstatic classThe tubular catalogue of the environment (tubulars: API 5CT / ISO 11960 by default; GOST 632-80 / 633-80 in Russia and the CIS...): standard casing and tubing sizes in the catalogue's unit, grades and connections - for validation and size choices.
TubularSettingsclassEnvironment section: the tubular catalogue offered in editors (casing and tubing sizes, grades, connections of a standard).
TubularStringclassA casing, liner, tubing or other tubular string: kind, depth range, cement and engineering attributes.
UncertaintySettingsclassPosition uncertainty settings.
UnitDefinitionclassA unit: its dimension, SI = value x Factor + Offset, and other spellings.
UnitEntryclassA unit as the unit catalog knows it: canonical symbol, dimension, SI = value x Factor + Offset.
Unitsstatic classUnit conversions through the current services' unit catalog (IUnitCatalog, default: the environment's units.definitions). Unknown units are reported, never guessed.
UnitSettingsclassEnvironment section: default depth unit and display units.
UnitSystemclassA unit system: the unit settings it fills.
ValidationSettingsclassEnvironment section: validation thresholds not covered by other sections.
VerificationSettingsclassEnvironment section: reference cases run by wellbore-config verify (known answers; add your own, for example ISCWSA test wells).
VocabularyDomainsstatic classVocabulary domains (what kind of code is being translated).
WbeTypeInfoclassA well barrier element type: code, name and its built-in acceptance-criteria reference.
WbeTypesstatic classWell barrier element vocabulary (names as used in NORSOK D-010 WBE tables). Default acceptance references are only given where verified (Rev 3, 2004); later revisions renumber the tables — set AcceptanceRef.
WellBarrierSetclassA well barrier schematic's data for one well state: envelopes, WBEs and the WBS header block (NORSOK D-010: well information, planned / as-built status, revision, prepared / verified by, notes).
WellboreClockstatic classThe time from the current services' IClock (the system clock while the services are being created).
WellboreEnvironmentclassEvery customer-adjustable setting of the wellbore family (units, thresholds, standards references, classification rules, styles, print / live / conversion defaults, resource overrides), loadable from a JSON file per customer, country or tenant. A file only needs the keys it changes; everything else keeps the built-in default (which reproduces the library's original behaviour). Physical constants and algorithm internals are deliberately not configurable.
WellboreIdsstatic classNew ids from the current services' IIdGenerator (random GUIDs while the services are being created).
WellboreInfoclassA drilled path (PPDM "Wellbore").
WellboreServicesclassThe configuration in effect: environment plus the contracts (vocabulary, lexicon, symbols, curve classifier, labels). Ambient (Current, scoped per request / tenant / test with WellboreServices)) or passed explicitly by DI hosts.
WellChangeclassOne difference between two states. Ids refer to state A (removed / modified) and state B (added / modified).
WellComponentclassAn item in a string or the wellbore: packer, nipple, valve, plug, pump…
WellDepthReferenceclassDepth reference system of a well: depth datum (KB, RT, DF, GL…) with its elevation above MSL, and the trajectory. MD and TVD are measured from the datum; TVDSS = TVD − datum elevation (positive below sea level).
WellHeaderclassWell identification and location: name, UWI, operator, field, coordinates and depth datums.
WellHistoryclassWell life-cycle: planned, as-built, workovers… as dated snapshots (source-agnostic, versioned JSON).
WellIdentifierFormatclassA national well identifier format: a regular expression over header fields, with an example for messages.
WellIdentifiersstatic classChecks well identifiers against the formats of the environment's country (region.wellIdentifiers).
WellModelclassThe library's canonical well: everything the well views need, independent of any source.
WellRecordabstract classCommon base: identity, provenance, preserved unmapped source fields.
WellStateclassOne documented state of a well (a full canonical snapshot).
WellStateDiffstatic classCompares two well states. Items match by id, then (for records from different systems or plans) by same type at the nearest depth within matchTolerance; matched items report field-level changes, unmatched ones are added / removed.
WellStateKindenumKind of well state kept in a well history (for example planned or as built).
WorldMagneticModelclassSpherical-harmonic geomagnetic model read from a NOAA .COF coefficient file (World Magnetic Model; the WMM2025 file is embedded). Any model in the same format can be configured (resources.geomagneticModelFile).

AbandonmentRuleSet class

A named abandonment rule set. A template leaves values empty for your engineers to fill in from the regulation's current edition; checks that need an empty value are skipped and reported (WP008), never filled with another regime's numbers.

MemberSummary
string EnvironmentalPlugDepthFrom { get; set; }What the environmental plug depth is measured from: "surface" (ground level / mudline) or "datum" (the schematic's depth zero).
Measure EnvironmentalPlugFoundationLength { get; set; }Minimum length of the environmental plug on a mechanical plug (none: environmentalPlugMinLength - no reduction; only some standards, e.g. NORSOK D-010, allow one).
Measure EnvironmentalPlugMaxDepth { get; set; }An environmental (surface) plug must have its top shallower than this depth.
Measure EnvironmentalPlugMinLength { get; set; }Minimum length of the environmental (surface) plug.
Measure FoundationPlugLength { get; set; }Minimum plug length on a mechanical foundation.
Measure FoundationTolerance { get; set; }A foundation counts when its top is within this distance of the plug base.
Measure MinPlugLength { get; set; }Minimum cement plug length without a mechanical foundation.
string Name { get; set; }Display name.
string Notes { get; set; }Notes (what to verify, where the values come from).
string Reference { get; set; }Regulation / standard the values come from.
List<string> SourceTypes { get; set; }Interval / component types treated as sources of inflow (plus open hole); empty: the abandonment section's.
string Status { get; set; }"in use" or "template" (values to be filled in).
List<string> MissingValues()Values the checks need that are empty (camelCase setting names).

AbandonmentSettings class

Environment section: permanent plug and abandonment checks. Defaults follow common NORSOK D-010 practice - verify against your standard's revision.

MemberSummary
string EnvironmentalPlugDepthFrom { get; set; }For this section's rule set: what the environmental plug depth is measured from ("datum" as before, or "surface").
Measure EnvironmentalPlugFoundationLength { get; set; }Minimum length of the environmental plug when set on a mechanical plug (NORSOK D-010 rev. 5: 50 m MD).
Measure EnvironmentalPlugMaxDepth { get; set; }An environmental (surface) plug must have its top shallower than this depth.
Measure EnvironmentalPlugMinLength { get; set; }Minimum length of the environmental (surface) plug (NORSOK D-010 rev. 5, open hole to surface: 100 m MD; on a mechanical plug: see environmentalPlugFoundationLength).
Measure FoundationPlugLength { get; set; }Minimum plug length when set on a mechanical or cement foundation (NORSOK D-010 rev. 5, cased hole: 50 m MD).
Measure FoundationTolerance { get; set; }A foundation counts when its top is within this distance of the plug base.
Measure MinPlugLength { get; set; }Minimum cement plug length (NORSOK D-010 rev. 5: 100 m MD; open hole: at least 50 m MD above any source of inflow).
string Reference { get; set; }Standard referenced by the checks (shown in the checklist).
string RuleSet { get; set; }Rule set in effect: a key of RuleSets; empty = the values of this section (the default rule set, NORSOK D-010).
Dictionary<string, AbandonmentRuleSet> RuleSets { get; set; }Other named rule sets; built in: US-BSEE (30 CFR 250.1715), UK-OEUK (OEUK guidelines), RU (Rostekhnadzor order No. 534); add your own.
List<string> SourceTypes { get; set; }Interval / component types treated as sources of inflow (plus open hole).
AbandonmentRuleSet Effective()The rule set in effect: the named one, else this section's values (named after Reference).

Annuli static class

Annulus identification from casing strings reaching surface, and annulus helpers such as fluid fill colours.

MemberSummary
static string FluidColor(AnnulusFluid f)Fill colour for a fluid from the environment's styles (built-in palette as fallback).
static List<AnnulusInfo> Identify(IEnumerable<(string, double, double)> strings, double surfaceTolerance = 50)Names surface-accessible annuli from strings that reach surface (top within surfaceTolerance), ordered by outer diameter: A between the two smallest, then B, C… Liners (not reaching surface) are skipped.
static AnnulusStatus Status(AnnulusInfo a)Status of the latest reading against MAWOP / MAASP.

AnnulusFluid enum

What fills an annulus (drives the drawn colour).

MemberSummary
UnknownFluid not recorded.
BrineCompletion brine.
WaterWater.
WaterBasedMudWater-based mud.
OilBasedMudOil-based mud.
DieselDiesel.
PackerFluidPacker fluid.
NitrogenNitrogen.
GasGas.
CementCement (annulus cemented).

AnnulusInfo class

One surface-accessible annulus (A = tubing / production casing, B = production / next casing, …) with its fluid, pressure history and limits. MAASP / MAWOP are normally supplied by well-integrity engineering; see MaaspScreening for a transparent screening estimate.

MemberSummary
AnnulusFluid Fluid { get; set; }Fluid in the annulus.
Quantity FluidDensity { get; set; }Fluid density (e.g. ppg or g/cm3) — used for hydrostatic gradients.
string InnerStringId { get; set; }Id of the string forming the inner wall.
AnnulusPressureReading Latest { get; }The most recent reading, or null without readings.
Quantity Maasp { get; set; }Maximum allowable annulus surface pressure.
Quantity Mawop { get; set; }Maximum allowable wellhead operating pressure (operating limit, below MAASP).
string Name { get; set; }Annulus name (A, B, C... from the inside out).
string Notes { get; set; }Free notes.
string OuterStringId { get; set; }Id of the string forming the outer wall.
List<AnnulusPressureReading> Readings { get; set; }Pressure readings, in any order.
Quantity ShoeFractureGradient { get; set; }Screening inputs: fracture gradient at the outer string shoe (e.g. psi/ft or ppg EMW) and wellhead / hanger rating.
Quantity WellheadRating { get; set; }Rating of the wellhead outlet / section for this annulus.

AnnulusPressureReading class

A recorded annulus pressure, compared against the annulus MAWOP and MAASP.

MemberSummary
DateTime Date { get; set; }Date and time of the reading.
Quantity Pressure { get; set; }Measured annulus pressure (surface).

AnnulusSettings class

Environment section: MAASP screening deratings.

MemberSummary
double BurstDerating { get; set; }MAASP screening: derating applied to the outer casing burst rating (0-1).
double CollapseDerating { get; set; }MAASP screening: derating applied to the inner string collapse rating (0-1).

AnnulusStatus enum

Annulus pressure status against its operating limits.

MemberSummary
NoDataNo reading or no limit to compare with.
OkLatest reading below MAWOP.
AboveMawopLatest reading above MAWOP but not above MAASP.
AboveMaaspLatest reading above MAASP.

AntiCollision static class

Anti-collision per the ISCWSA separation rule (SPE-187073): closest approach of each offset well along the reference well, separation factor, MASD and allowable deviation from plan from the ISCWSA position uncertainty (pedal-curve projection along the centre-to-centre line). Wells are placed in a local east-north-up frame around the reference wellhead (WGS84), depths below mean sea level via each well's depth datum, azimuths to true north.

MemberSummary
static double Masd(double sigmaS, double rRef, double rOff, AntiCollisionSettings s)The minimum allowable separation distance of the rule.
static AntiCollisionResult Scan(WellModel reference, IEnumerable<WellModel> offsets, List<string> warnings = null, AntiCollisionSettings settings = null)Scans the reference well against the offset wells.
static double SeparationFactor(double distance, double sigmaS, double rRef, double rOff, AntiCollisionSettings s)The separation factor of the rule.
static string ToCsv(AntiCollisionResult r)The scan as CSV: per offset the minimum separation factor and the closest approach, then every point.

AntiCollisionResult class

Result of an anti-collision scan.

MemberSummary
List<OffsetSeparation> Offsets { get; }Offset wells scanned.
string Reference { get; set; }Reference well name.

AntiCollisionSettings class

Environment section: anti-collision (ISCWSA separation rule, SPE-187073, Sawaryn et al. 2019): SF = (D - Rref - Roff - Sm) / (k * sqrt(sigmaS^2 + sigmaPA^2)); MASD = k * sqrt(...) + Rref + Roff + Sm; ADP = D - MASD.

MemberSummary
bool GeomagneticCorrelation { get; set; }Correct the combined covariance for geomagnetic reference errors shared by both wells (ISCWSA technical supplement, SPE-67616 eq. A.24).
List<SeparationLevel> Levels { get; set; }Levels (ISCWSA e-book, separation rules: report below 4.0; adjust the plan below 1.5 - for many operators the limit to shut in adjacent wells; adjust below 1.25; never plan below 1.0).
List<string> OffsetColors { get; set; }Colours of offset wells on the plots, in turn.
Measure ProjectAhead { get; set; }Project-ahead uncertainty, 1 sigma (SPE-187073: 0.5 m).
double ScalingFactor { get; set; }Dimensionless scaling factor k (SPE-187073: 3.5).
Measure ScanRadius { get; set; }Offset wells whose wellhead is farther than this from the reference wellhead are left out.
Measure ScanStep { get; set; }MD step of the reference-well scan.
Measure SurfaceMargin { get; set; }Surface margin Sm (SPE-187073: 0.3 m).

AttributeRule class

A rule for one equipment attribute: what kind of value, its unit, whether it is required, allowed values or range.

MemberSummary
List<string> Choices { get; set; }Allowed values (choice).
string Key { get; set; }Attribute key: a built-in field (pressureRating, material, serialNumber, od, ...) or a company key stored in Extra.
string Kind { get; set; }text, number, quantity, date or choice.
string Label { get; set; }Label (tally header, messages).
double? Max { get; set; }Maximum (number / quantity, in Unit).
double? Min { get; set; }Minimum (number / quantity, in Unit).
bool Required { get; set; }A value is required.
string Unit { get; set; }Unit of quantities (values in any unit of the same dimension are accepted; ranges and display use this unit).

AuditAction enum

What an audit entry records.

MemberSummary
AddedAn item was added.
RemovedAn item was removed (or marked removed).
ModifiedA field of an item changed.
NoteA note without a data change (review, approval...).

AuditEntry class

One audited change of a well: when, who, what (item and field), before and after, and why.

MemberSummary
AuditAction Action { get; set; }What kind of change.
string After { get; set; }Value after (text).
string Author { get; set; }Who made it.
string Before { get; set; }Value before (text).
string EntityId { get; set; }Id of the item.
string EntityType { get; set; }Kind of item (String, Component, Interval, Header...).
string Field { get; set; }Field changed (modifications).
string Id { get; set; }Entry id.
string Label { get; set; }Item label at the time of the change.
string Reason { get; set; }Why the change was made.
string Source { get; set; }Tool or process that made the change (schematic editor, import, ...).
DateTime Utc { get; set; }When the change was made (UTC).

BarrierDocumentStatus enum

Barrier planning / documentation state (must be stated on a WBS).

MemberSummary
PlannedPlanned barrier set.
AsBuiltAs built.

BarrierElement class

One well barrier element (WBE).

MemberSummary
string AcceptanceRef { get; set; }Acceptance criteria reference (standard + table), e.g. "NORSOK D-010 Rev 3 Table 22".
Quantity Bottom { get; set; }Bottom of the element interval (cement, casing).
string DisplayName { get; }Element name, else the element type name.
string Id { get; set; }Element id (tags on the schematic).
string Name { get; set; }Display name; defaults to the type name.
string Notes { get; set; }Notes.
BarrierElementStatus Status { get; set; }Current status.
string TargetId { get; set; }Id of the component / string the element refers to.
string TargetKey { get; }Identity of the physical thing (used to detect common WBEs across envelopes).
BarrierTargetKind TargetKind { get; set; }What the element refers to.
Quantity Top { get; set; }Optional interval (strings, cement, formation, fluid column).
string Type { get; set; }WBE type code, see WbeTypes (e.g. CASING_CEMENT, DHSV).
string VerificationMethod { get; set; }How it was verified (pressure test, CBL, inflow test…).
DateTime? VerifiedDate { get; set; }Date of the last verification.

BarrierElementStatus enum

Well barrier element condition. Worst element status sets the envelope status.

MemberSummary
IntactVerified and holding.
UnverifiedInstalled but not verified.
ImpairedDegraded (may not hold as designed).
FailedNot holding.

BarrierEnvelope class

One well barrier envelope (primary, secondary or environmental) and its elements.

MemberSummary
List<BarrierElement> Elements { get; set; }The elements of the envelope.
BarrierRole Role { get; set; }Primary, secondary or environmental.
BarrierElementStatus Status { get; }Worst element status (Intact when empty elements are validated separately).

BarrierEvidence static class

Turns cement bond evidence into status proposals for casing-cement barrier elements: Intact (verified) when the longest CONTINUOUS good-bond interval inside the element reaches the required isolation length, Impaired otherwise; Unverified when less than the minimum fraction of the element was logged (a log that barely touches an element cannot verify it); no proposal where it was not logged at all. Nothing changes until Boolean) is called.

MemberSummary
static int Apply(IEnumerable<BarrierStatusProposal> proposals, DateTime verifiedOn, string method, bool overrideFailed = false)Applies reviewed proposals: status, verification date and method, reason appended to notes. Proposals for elements recorded FAILED are skipped unless overrideFailed is set deliberately. Returns how many were applied.
static List<BarrierStatusProposal> ProposeCementStatus(WellBarrierSet set, Func<BarrierElement, (double, double)?> elementInterval, IReadOnlyList<CementBondEvidence> evidence, string unit, string method)Proposes a status for every cement element with evidence: Intact when the longest continuous good bond reaches the required length and coverage the minimum; otherwise Impaired. Proposals are reviewed, then applied explicitly.
static List<BarrierStatusProposal> ProposeCementStatus(WellBarrierSet set, Func<BarrierElement, (double, double)?> elementInterval, IReadOnlyList<CementBondEvidence> evidence, double requiredLength, string unit, string method, double? minCoverage = null)Proposals with the environment's required isolation length (cement.minIsolationLength, default 10 ft) and minimum coverage.

BarrierIssue class

A barrier or annulus validation finding: code, severity, message and the element concerned.

MemberSummary
BarrierIssue(BarrierIssueSeverity severity, string code, string message, string elementId = null)Creates an issue with its severity, code, message and optionally the element it concerns.
string Code { get; }Stable code.
string ElementId { get; }Id of the element concerned.
string Message { get; }What is wrong.
BarrierIssueSeverity Severity { get; }How serious the issue is.
string ToString()Severity, code and message on one line.

BarrierIssueSeverity enum

Severity of a barrier or annulus validation finding.

MemberSummary
InfoInformation.
WarningShould be reviewed.
ErrorThe set is not valid.

BarrierRole enum

Which barrier an envelope is (NORSOK D-010 colours: primary blue, secondary red, environmental green).

MemberSummary
PrimaryPrimary well barrier (first envelope against the source).
SecondarySecondary well barrier (back-up).
EnvironmentalOpen hole to surface (environmental) barrier.

BarrierSettings class

Environment section: barrier requirement, impaired-element rule and acceptance-criteria references.

MemberSummary
Dictionary<string, string> AcceptanceReferences { get; set; }Acceptance-criteria reference per WBE type (standard + table). Defaults: only NORSOK D-010 Rev 3 tables verified; set your revision / company standard.
bool CountImpaired { get; set; }Count impaired elements as barriers in leak-path analysis.
int RequiredBarriers { get; set; }Barriers required on every leak path (two-barrier principle).

BarrierStatusProposal class

A proposed barrier element status change with its reason — reviewed, then applied explicitly.

MemberSummary
bool Blocked { get; set; }True when the element is recorded FAILED: a log cannot clear a failure (that takes remedial work and explicit re-verification), so Boolean) skips it unless told to override.
double Coverage { get; set; }Fraction (0-1) of the element interval covered by logged evidence.
BarrierElementStatus Current { get; set; }Status recorded now.
BarrierElement Element { get; set; }The cement element the proposal is for.
double LongestGood { get; set; }Length of the longest continuous good-bond run inside the element interval (document depth unit).
BarrierElementStatus Proposed { get; set; }Status the evidence supports.
string Reason { get; set; }Why (continuous good bond and coverage against the requirements).
BarrierRole Role { get; set; }Envelope the element belongs to.

BarrierTargetKind enum

What part of the well a barrier element refers to.

MemberSummary
ComponentAn equipment item (packer, DHSV, tree, hanger, plug…) by id.
StringA casing / liner / tubing string by id (optionally only [Top, Bottom]).
CementThe cement sheath of a string by id (optionally only [Top, Bottom]).
FormationIn-situ formation over [Top, Bottom].
FluidColumnA fluid column (drilling / workover) over [Top, Bottom].

BarrierValidator static class

Barrier checks derived from NORSOK D-010 well barrier principles: two envelopes, common WBEs flagged for risk assessment, failed / impaired / unverified elements reported, references resolvable, casing and cement WBEs carrying size and depth. Target existence is checked through a caller-supplied resolver (source-agnostic).

MemberSummary
static IReadOnlyList<BarrierIssue> Validate(WellBarrierSet set, Func<BarrierElement, bool> targetExists = null, Func<BarrierElement, bool> hasSizeAndDepth = null)Validates a barrier set: envelopes, element types, statuses, acceptance references and (when the callbacks are given) target existence and sizing.

BrandingSettings class

Environment section: the trademark footnote (and optional logo) on exports, prints and views.

MemberSummary
string Footnote { get; set; }Footnote text on every export, print and view.
string LogoFile { get; set; }Logo file drawn before the footnote (PNG or JPEG, relative to the environment file); null = the built-in The Tech Idea logo.
bool ShowInExports { get; set; }Show the footnote in PDF / SVG / PNG exports and prints.
bool ShowLogo { get; set; }Draw a logo before the footnote.
bool ShowOnScreen { get; set; }Show the footnote in the corner of interactive views.

BuiltInToolModels static class

The tool models embedded in this library (tool-models.json); environments add their own in survey.toolModels.

MemberSummary
static Dictionary<string, ToolErrorModel> All()A fresh copy of the built-in models by name.

CasingCheck class

A string's ratings against the loads: design factors and whether each meets the minimum.

MemberSummary
double? BurstFactor { get; }Burst design factor.
double? BurstLoad { get; set; }Burst load (psi).
double? CollapseFactor { get; }Collapse design factor.
double? CollapseLoad { get; set; }Collapse load at the shoe (psi).
bool? Pass { get; set; }Whether every computed design factor meets its minimum (null when nothing could be checked).
CasingRating Rating { get; set; }The ratings.
double? TensionFactor { get; }Tension design factor.
double? TensionLoad { get; set; }Tension load at the top (lbf, buoyed).

CasingDesign static class

Casing design checks with the API Bulletin 5C3 / API TR 5C3 formulas behind the API 5CT / 5C2 tables: burst (Barlow, 87.5 % wall), collapse in four regimes by D/t (yield, plastic, transition, elastic; A, B, C, F, G rounded as API tabulates them) and pipe-body tension; rounding as API (10 psi, 1000 lbf).

MemberSummary
static double Burst(double odIn, double wallIn, double yieldPsi)Internal yield (burst) pressure, psi: 0.875 * 2 Yp t / D, nearest 10.
static List<CasingCheck> Check(WellModel model, CasingLoadCase loads = null, CasingDesignSettings settings = null, List<string> warnings = null)Checks the casing strings of a model against simple loads (full evacuation, test pressure, buoyed weight).
static (double, string) Collapse(double odIn, double wallIn, double yieldPsi)Collapse pressure (psi, nearest 10) and regime.
static CasingRating Rate(TubularString str, CasingDesignSettings settings = null)Ratings of a string from its attributes (OD, ID or nominal weight, grade).
static double Tension(double odIn, double wallIn, double yieldPsi)Pipe-body yield strength, lbf: pi/4 (D^2 - d^2) Yp, nearest 1000.
static double? YieldOf(string grade, CasingDesignSettings settings = null)Minimum yield (psi) of a grade - exact name, else its base (L80-13Cr, L80-1 -&gt; L80; N80Q -&gt; N80).

CasingDesignFactors class

Minimum design factors (rating / load).

MemberSummary
double Burst { get; set; }Burst (internal yield) - default 1.25: an operator's published minimum (Devon Energy, EPA hydraulic fracturing workshop 2011).
double Collapse { get; set; }Collapse - default 1.1 (same source).
double Tension { get; set; }Tension (pipe body yield) - default 1.4 (same source).

CasingDesignSettings class

Environment section: casing design checks (API TR 5C3 / API Bulletin 5C3 ratings).

MemberSummary
CasingDesignFactors DesignFactors { get; set; }Minimum design factors.
Dictionary<string, double> GradeYield { get; set; }Minimum yield strength per grade (ksi), API Spec 5CT; grades are matched by their base (L80-13Cr -&gt; L80).
string Method { get; set; }Rating method: "API 5C3" (the API formulas behind the API 5CT / 5C2 tables). ISO/TR 10400 ductile-rupture burst is not yet implemented.
List<PipeDimension> PipeDimensions { get; set; }Nominal weight -&gt; wall thickness for strings recorded without an inside diameter; built in: rows checked against published API 5CT data; add yours.
Measure SteelDensity { get; set; }Steel density for buoyancy (carbon steel 7.85 g/cm3).

CasingLoadCase class

Loads of a simple design check.

MemberSummary
Measure FluidGradient { get; set; }Fluid gradient outside the casing (mud), for full-evacuation collapse and buoyancy: a density (ppg, g/cm3) or a gradient.
Measure TestPressure { get; set; }Surface test pressure (burst load over the string).

CasingRating class

API 5C3 ratings of one string (psi, lbf); null where the pipe could not be rated (see Notes).

MemberSummary
double? Burst { get; set; }Internal yield (burst) pressure (psi, nearest 10).
double? Collapse { get; set; }Collapse pressure (psi, nearest 10).
string CollapseRegime { get; set; }Collapse regime: Yield, Plastic, Transition or Elastic.
string Grade { get; set; }Grade as recorded.
string Name { get; set; }String name.
List<string> Notes { get; }Why the pipe was not (fully) rated, and differences from recorded ratings.
double? OuterDiameter { get; set; }Outside diameter (in).
string StringId { get; set; }String id.
double? Tension { get; set; }Pipe body yield strength (lbf, nearest 1000).
double? Wall { get; set; }Wall thickness (in).
double? Yield { get; set; }Minimum yield strength (psi).

CavityKind enum

Role of a cavity in a leak-path network: the source (reservoir), an intermediate cavity or the sink (surroundings).

MemberSummary
SourceThe reservoir (where a leak starts).
CavityA space in the well (annulus, bore...).
SinkThe surroundings (where a leak ends).

CementBondClass enum

Cement bond quality class used as barrier evidence.

MemberSummary
GoodGood bond (hydraulic seal expected).
PartialPartial bond.
PoorPoor or no bond.

CementBondEvidence class

Source-neutral cement bond evidence (from a CBL/VDL, ultrasonic log…): one classified interval, document depth unit.

MemberSummary
double Bottom { get; set; }Bottom of the interval (document depth unit).
CementBondClass Class { get; set; }Bond class of the interval.
double Top { get; set; }Top of the interval (document depth unit).

CementSettings class

Environment section: CBL calibration, bond-index cutoffs and cement-barrier verification rules.

MemberSummary
string AmplitudeUnit { get; set; }Unit of freePipeAmplitude / bondedAmplitude (mV); CBL curves in another voltage unit are converted to it.
float BondedAmplitude { get; set; }CBL amplitude at 100 % bond (mV).
float FreePipeAmplitude { get; set; }CBL amplitude in free pipe (mV) — replace with your tool / casing calibration.
float GoodBondIndex { get; set; }Bond index at or above which bond is good.
double MinCoverage { get; set; }Minimum fraction of a cement element that must be logged to verify it.
Measure MinIsolationLength { get; set; }Continuous good bond required for a cement barrier element to be verified.
float PoorBondIndex { get; set; }Bond index below which bond is poor.

ChangeKind enum

Kind of difference between two well states: added, removed or modified.

MemberSummary
AddedItem added.
RemovedItem removed.
ModifiedItem changed.

ColorStop class

A colour at a position (0 to 1) in a palette.

MemberSummary
ColorStop()An empty colour stop (for deserialization).
ColorStop(double at, string color)A colour at a position (0-1) of a palette.
double At { get; set; }Position 0-1.
string Color { get; set; }Colour at this position (#rrggbb).

ComponentTypeInfo class

One canonical component type.

MemberSummary
ComponentTypeInfo(string code, string category, string name)Creates type information: code, category and display name.
string Category { get; }Category (completion, wellhead, drilling...).
string Code { get; }Canonical code, for example PACKER_PERMANENT.
string Name { get; }Display name.

ComponentTypes static class

Canonical component vocabulary. Source codes translate to these through mapping-profile code tables; renderers map these to symbols. Keep codes stable: they are persisted.

MemberSummary
static IReadOnlyList<ComponentTypeInfo> All { get; }Component types of the model catalog in effect (default: the built-in model-catalog.json; configurable).
static ComponentTypeInfo Get(string code)The component type of a code in the catalog in effect, or null.
static bool IsKnown(string code)True when the code is a component type of the catalog in effect.

ConfigIssue class

A problem found in a configuration resource file (lexicon, vocabulary, labels, symbols), with a stable code.

MemberSummary
ConfigIssue(ConfigIssueSeverity severity, string code, string message, string file = null)Creates an issue with its severity, stable code, message and (optionally) the file it was found in.
string Code { get; }Stable code (WRnnn) listed in the validation catalog.
string File { get; set; }The resource file the issue was found in (set when loading).
string Message { get; }What is wrong and what happens as a result.
ConfigIssueSeverity Severity { get; }How serious the issue is.
string ToString()File, code, severity and message on one line.

ConfigIssueSeverity enum

How serious a problem in a configuration resource file is.

MemberSummary
ErrorThe file cannot be used as intended (for example a duplicate unit id).
WarningThe file is used but part of it is ignored or ambiguous.
InfoInformation only.

ConfigurationChecks static class

Cross-checks of the configured parts that only fail when used (CV001-CV006).

MemberSummary
static List<ConfigIssue> Run(WellboreServices s)Checks leak-path networks, identifier patterns, abandonment rule sets, the model catalog and symbol roles of s.

ConfigurationSaveReport class

What String) wrote, and the parts it could not save (host implementations that are not JSON).

MemberSummary
List<string> Files { get; }Files written, relative to the folder (environment.json first).
List<string> Skipped { get; }Parts not saved, with the reason.

ConfiguredFiles static class

Files an environment names (resources.lithologyFile, resources.symbolCatalogFile...): resolved against the environment's folder, read once per file version, and reported in the services' warnings when missing or broken - never silently replaced.

MemberSummary
static T Load<T>(string file, Func<string, T> read, string what)The object a configured file holds (null when no file is configured, or it cannot be read - said in the services' warnings).
static string Resolve(string file)The full path of a configured file (relative paths against the current environment's folder), or null when none.

ContactInterval class

Perforation / open interval / slotted section (PPDM "Wellbore Contact Interval").

Inherits / implements: WellRecord

MemberSummary
Quantity Bottom { get; set; }Bottom of the interval.
DateTime? Date { get; set; }Date.
double? PhasingDegrees { get; set; }Perforation phasing (degrees).
Quantity ShotDensity { get; set; }Shots per length.
ItemStatus Status { get; set; }Status.
Quantity Top { get; set; }Top of the interval.
string Type { get; set; }Interval type (PERFORATION, OPEN_HOLE...).
string WellboreId { get; set; }Wellbore the interval is in.
string Zone { get; set; }Zone.

ContactTypeInfo class

A fluid contact type: code, name, drawing colour, rank from the top and limit direction.

MemberSummary
ContactTypeInfo(string code, string name, string color, int rank, int limit)Creates a contact type.
string Code { get; }Code (GOC, OWC...).
string Color { get; }Conventional colour (#rrggbb); the environment's styles.contactColors win.
int Limit { get; }0 = a level, +1 = fluid proven down to here, -1 = fluid proven up to here.
string Name { get; }Name.
int Rank { get; }Rank from the top (lower = shallower fluid).

ConversionSettings class

Environment section: defaults for converting a well model into schematic and wellbore views.

MemberSummary
bool AddCasingShoes { get; set; }Add casing shoes at string bottoms.
string DepthMode { get; set; }Depth scale of converted views: True or Compressed.
string Dimensioning { get; set; }Schematic dimensioning: Scaled (real diameters) or Schematic.
bool GenerateAnnuli { get; set; }Identify annuli from strings when the source has none.
bool GenerateBarriers { get; set; }Generate a typical barrier set when the source has none (marked Planned).
bool InstalledOnly { get; set; }Show only installed items (not removed / abandoned).
bool LabelComponents { get; set; }Label components with their names.
bool ShowBarrierTable { get; set; }Add the barrier / integrity table when barrier or annulus data exists.
bool ShowTrajectory { get; set; }Add a deviation track when a survey exists.

CoreSample class

One core-plug measurement set at a depth (driller's core depth; see CoreShift).

Inherits / implements: WellRecord

MemberSummary
string CoreNumber { get; set; }Core number the sample belongs to.
Quantity Md { get; set; }Measured depth of the sample (driller's depth before any core shift).
Dictionary<string, double> Values { get; set; }Measured properties by canonical key: porosity (v/v), permeability (mD), grainDensity (g/cm3), sw (v/v)…

CoreShift class

Core-to-log depth shift for one core (added to core depths).

MemberSummary
string CoreNumber { get; set; }Core number the shift applies to.
Quantity Shift { get; set; }Depth shift applied to the core's samples (positive = deeper).

CorrelationSettings class

Environment section: correlation panel defaults.

MemberSummary
string Reference { get; set; }Default vertical reference: MD, TVD or TVDSS.
bool ShowWellheads { get; set; }Show wellhead stacks above the plots.
float WellGap { get; set; }Gap between wells (px).

CountryPresets static class

Ready-made country environments through the current services' country catalog (ICountryCatalog, default: the 62 built-in countries generated by tools/countries). Use "extends": "country:RU" and override anything in your file.

MemberSummary
static IReadOnlyList<string> Codes { get; }Country codes with a preset in the current catalog, sorted.
static WellboreEnvironment Load(string code)The environment of a country preset alone (no company settings).
static string NameOf(string code)The name of a country preset's country.
static bool TryGet(string code, string json)The preset JSON of a country (ISO 3166 two-letter code) from the current catalog; false when there is none.

CrossplotSettings class

Environment section: crossplots (density-neutron lithology lines, Pickett saturation lines, point style).

MemberSummary
List<double> DensityNeutronDensityRange { get; set; }Density-neutron density axis [min, max] (g/cm3).
List<LithologyLine> DensityNeutronLines { get; set; }Density-neutron lithology lines. Limestone is exact for a limestone-calibrated neutron; sandstone and dolomite offsets are approximate defaults - replace them with your tool's chart values.
List<double> DensityNeutronNeutronRange { get; set; }Density-neutron neutron axis [min, max] (v/v, limestone units).
List<double> PickettPorosityRange { get; set; }Pickett porosity axis [min, max] (v/v, logarithmic).
List<double> PickettRtRange { get; set; }Pickett resistivity axis [min, max] (ohm.m, logarithmic); points outside are reported.
string PickettSwLine { get; set; }Pickett plot: colour of the other Sw lines.
List<double> PickettSwLines { get; set; }Water saturations drawn as Pickett lines (fractions).
string PickettWaterLine { get; set; }Pickett plot: colour of the Sw = 1 (water) line.
string PointColor { get; set; }Colour of points without zone or colour curve.
float PointSize { get; set; }Point radius (px).
string RampHigh { get; set; }Colour-curve ramp, high end.
string RampLow { get; set; }Colour-curve ramp, low end.

CrossSectionSettings class

Environment section: cross-section defaults.

MemberSummary
double MaxOffset { get; set; }Flag wells farther than this from the section line (0 = no limit), in the panel unit.
float? VerticalExaggeration { get; set; }Fixed vertical exaggeration; null = fit the panel.

CurveDepthShift class

A recorded depth correction of one curve (auditable: who, when, why). One tie point is a bulk shift; several tie points match depths piecewise-linearly between them and shift by the end offsets beyond the first / last point.

Inherits / implements: WellRecord

MemberSummary
DateTime Date { get; set; }When it was made (UTC).
string Interpreter { get; set; }Who made it.
string LogSetName { get; set; }Log set the curve belongs to (null = any).
string Mnemonic { get; set; }Mnemonic of the shifted curve.
string Reason { get; set; }Why the shift was made.
List<DepthTiePoint> TiePoints { get; set; }Tie points: one = bulk shift; several = piecewise-linear matching.
bool ApplyTo(LogSet set)Applies the shift to a curve of a shared-index log set: the curve's samples are moved, then resampled linearly onto the set's index (null where the moved curve does not cover an index depth). Returns false when the curve is not in the set.
static CurveDepthShift Bulk(string mnemonic, Quantity offset, string reason = null)A bulk shift: every sample moves by offset (unit of the offset).
double Map(double depth, string unit)The corrected depth of a logged depth (both in unit).

CurveFamilyRule class

A log curve family (track) and the mnemonics that belong to it.

MemberSummary
MnemonicMatch Match { get; set; }Which mnemonics belong to this family (first matching family wins).
string Name { get; set; }Family / track name, e.g. Gamma Ray.
int Order { get; set; }Track order (lower first).

CurvePresentation class

Resolved presentation of a log curve.

MemberSummary
string Brush { get; set; }Area-fill brush key; null for none.
string Color { get; set; }Curve colour (#rrggbb); null keeps the default.
string Family { get; set; }Curve family (track grouping), for example Gamma Ray or Resistivity.
string Fill { get; set; }Fill mode; null for none.
double? Max { get; set; }Scale maximum from the curve rules.
double? Min { get; set; }Scale minimum from the curve rules (null: from the data).
int Order { get; set; }Order of the family's track (lower first).
string Scale { get; set; }Scale type (Linear or Logarithmic); null keeps the default.
float? StrokeWidth { get; set; }Line width in pixels; null keeps the default.
string Unit { get; set; }Unit of Min / Max.

CurveStyleRule class

Presentation (colour, scale, fill, brush, line width) for the curves matching a rule.

MemberSummary
string Brush { get; set; }Fill / lithology key from the lithology library.
string Color { get; set; }Line colour (#rrggbb).
string Fill { get; set; }Fill mode: None, LeftToCurve, RightToCurve, BetweenCurves, CutoffShading.
MnemonicMatch Match { get; set; }Which curves this style applies to (first matching rule wins).
double? Max { get; set; }Scale maximum for matching curves (e.g. GR 150).
double? Min { get; set; }Scale minimum for matching curves (a company's standard presentation, e.g. GR 0); with Max.
string Scale { get; set; }Scale: Linear or Log10.
float? StrokeWidth { get; set; }Line width (px).
string Unit { get; set; }Unit of min / max (converted to each curve's unit when they differ); none: the curve's unit.

CurveValueCheck class

A curve value a "dataSource" verification case expects: the curve (in a named log set, or any), the index and the value.

MemberSummary
string Curve { get; set; }Curve mnemonic.
double Index { get; set; }Index value (depth or time in the set's index unit) of the sample.
string LogSet { get; set; }Log set name (none: the first set holding the curve).
double Value { get; set; }Expected value.

CuttingsSample class

Cuttings description over a sample interval: lithology percentages (shared lithology codes).

Inherits / implements: WellRecord

MemberSummary
Quantity Bottom { get; set; }Bottom of the sample interval.
string Description { get; set; }Lithology description.
Dictionary<string, double> Percentages { get; set; }Lithology code -&gt; percent of the sample (should total ~100).
Quantity Top { get; set; }Top of the sample interval.

DataSourceDefinition class

A company data source named in the environment: what it is (kind), where (path, relative to the environment file), the mapping profile it is read with, and the company's own overrides over that profile (code values, row filters). Open it with the loaders library's DataSources; check it with a "dataSource" verification case.

MemberSummary
Dictionary<string, Dictionary<string, Dictionary<string, string>>> Codes { get; set; }Company code values over the profile: entity -&gt; field -&gt; source code -&gt; canonical code (for example PPDM TUBING_TYPE codes).
string Description { get; set; }What the source is.
string Encoding { get; set; }Text encoding of CSV files (empty: detected).
string Kind { get; set; }csv (folder), excel (.xlsx), edmXml (Landmark EDM export), las, dlis, witsml - or a kind a host registers (for example a database).
List<double> NullValues { get; set; }DLIS sample values meaning no data (none: -999.25).
string Path { get; set; }File or folder (relative to the environment file); for host kinds, whatever the host expects (for example a connection name).
string Profile { get; set; }Mapping profile for tabular kinds (csv, excel, edmXml, host databases); default csv, or edm for edmXml.
Dictionary<string, Dictionary<string, string>> Where { get; set; }Row filters over the profile: entity -&gt; column -&gt; value (for example the EDM design case).

DatumElevation class

Elevation of a depth datum (KB, RT, DF, GL...) above its reference, usually mean sea level.

MemberSummary
string Code { get; set; }KB, RT, DF, GL, MSL, SB, CBF…
Quantity Elevation { get; set; }Elevation above the reference (usually MSL).
string Reference { get; set; }Reference the elevation is measured from (MSL by default).

DepthPath enum

Depth path.

MemberSummary
MDMeasured depth along the hole.
TVDTrue vertical depth below the datum.
TVDSSTrue vertical depth below sea level.

DepthTiePoint class

A depth-matching tie point: the logged depth From belongs at To.

MemberSummary
Quantity From { get; set; }The logged depth.
Quantity To { get; set; }The depth it belongs at.

Dimension enum

Unit dimensions known to the registry.

MemberSummary
LengthLength (m, ft...).
LinearMassMass per length (kg/m, lbm/ft).
PressurePressure (Pa, psi, bar...).
TemperatureTemperature (degC, degF, K).
DensityDensity (kg/m3, g/cm3, ppg).
AngleAngle (deg, rad).
GammaRayNatural gamma ray in API units (gAPI; defined by the API RP 33 calibration pit - no conversion).
ResistivityElectrical resistivity (ohm.m).
SlownessAcoustic slowness (s/m: us/ft, us/m).
FractionDimensionless fraction (v/v, %, porosity units).
ElectricPotentialElectric potential (V, mV - spontaneous potential).
ConductivityElectrical conductivity (S/m, mS/m, mmho/m).
PressureGradientPressure gradient (Pa/m: psi/ft, kPa/m, bar/m, MPa/m ...).
ExposureRateGamma exposure rate (uR/h - Russian / CIS gamma-ray logs, мкР/ч); not convertible to API units (tool-dependent).
ForceForce (N: kN, lbf, klbf, kgf, tf).
FlowRateVolumetric flow rate (m3/s: gpm, bbl/min, L/min, m3/min, m3/h).

DipAzimuthReference enum

What a dip azimuth is measured from.

MemberSummary
NorthFrom north (true, grid or magnetic - see the pick's north reference).
HighSideFrom the high side (top) of the hole, clockwise looking down-hole.

DipConversion static class

Dip geometry between the earth and the borehole. Frames (north / east / down): the hole axis t = (sin I cos A, sin I sin A, cos I), its high side h = (cos I cos A, cos I sin A, -sin I) and r = t x h (clockwise from h looking down-hole). A bed of dip d toward azimuth a has the upward normal n = (sin d cos a, sin d sin a, -cos d); relative to the hole n = sin d' (cos a' h + sin a' r) - cos d' t. The dip azimuth is the direction of the deepest point of the bed's sinusoid on an image.

MemberSummary
static double HighSideToNorth(double highSideAzimuth, double inclination, double azimuth)An azimuth around the hole measured from the high side as one measured from north (projected across the hole).
static DipMeasurement Normalise(DipMeasurement pick, WellHeader header, Trajectory trajectory, string depthUnit, List<string> warnings = null)The pick as a true dip with its azimuth from the working north (a copy; other fields kept). Borehole-relative picks need the hole's orientation from trajectory (azimuths in the working north; none: a vertical hole is assumed, said in the warnings); north-referenced azimuths are corrected from the pick's north (declination, convergence from the header).
static double NorthAngleFromHighSide(double inclination, double azimuth)Angle from the high side, clockwise looking down-hole, of the direction north projects to across the hole (degrees).
static double NorthToHighSide(double northAzimuth, double inclination, double azimuth)An azimuth around the hole measured from north (projected across the hole) as one measured from the high side.
static (double, double)? Orientation(Trajectory trajectory, double md)Inclination and azimuth of the hole at a measured depth (along the minimum-curvature arc between stations); null without a survey.
static (double, double) ToBoreholeRelative(double dip, double azimuth, double inclination, double boreholeAzimuth)Borehole-relative dip and its azimuth from the high side, from a true dip and azimuth (degrees).
static (double, double) ToTrue(double relativeDip, double highSideAzimuth, double inclination, double azimuth)True dip and azimuth from a borehole-relative dip (azimuth from the high side) in a hole of inclination / azimuth (degrees).

DipFrame enum

What a dip angle is measured against.

MemberSummary
TrueAgainst the horizontal (geographic, true dip).
BoreholeRelativeAgainst the plane across the borehole (as a dipmeter or image log measures it).

DipMeasurement class

A structural dip pick: angle and azimuth of the dip direction (the deepest point of its sinusoid). By default a true (geographic) dip with its azimuth from north; Frame, AzimuthReference and NorthReference say otherwise (null: the environment's dips section). String}) turns any pick into a true dip in the working north.

Inherits / implements: WellRecord

MemberSummary
double Azimuth { get; set; }Dip direction azimuth, degrees clockwise from north, 0-360.
DipAzimuthReference? AzimuthReference { get; set; }Azimuth measured from north or from the high side of the hole (clockwise looking down-hole); null: environment default.
double Dip { get; set; }Dip angle, degrees 0-90.
DipFrame? Frame { get; set; }True (relative to horizontal) or borehole-relative (relative to the plane across the hole); null: environment default.
Quantity Md { get; set; }Measured depth of the dip.
NorthReference? NorthReference { get; set; }North a north-referenced azimuth refers to; null: environment default, else the well's survey north.
string Quality { get; set; }Pick quality (e.g. A/B/C).
DipType Type { get; set; }Kind of feature.

DipSettings class

Conventions of dip picks that do not state their own.

MemberSummary
string AzimuthReference { get; set; }What dip azimuths are measured from: North or HighSide.
string Frame { get; set; }Frame of dip angles: True or BoreholeRelative.
string NorthReference { get; set; }North of north-referenced dip azimuths: True, Grid or Magnetic; none: the well's survey north.

DipType enum

Kind of planar feature a dip pick represents (bedding, fracture, fault...).

MemberSummary
BeddingBedding plane.
CrossBeddingCross-bedding.
FractureOpenOpen (conductive) fracture.
FractureHealedHealed (resistive) fracture.
FaultFault.
UnconformityUnconformity.
UnknownNot classified.

DisplayFormat static class

Numbers and dates as they appear on screen and in printed output, by the environment's locale section. Files (CSV, LAS, WITSML, JSON) never use it: they stay invariant whatever the locale or the machine's culture.

MemberSummary
static CultureInfo Culture { get; }The display culture (invariant when locale.culture is empty or unknown); with locale.calendar Gregorian its dates use the Gregorian calendar.
static TimeZoneInfo TimeZone { get; }The display time zone: locale.timeZone, else the machine's own.
static string Date(DateTime value)A date for display (locale.dateFormat).
static string DateTime(DateTime value)A date and time for display (locale.dateTimeFormat).
static bool IsDatePattern(string pattern)True when the pattern formats a date.
static string Number(double value, string format)A number for display.
static DateTime ToDisplayTime(DateTime utc)A stored (UTC) time in the display time zone (locale.timeZone).
static CultureInfo TryCulture(string name)A culture by name, or null when the name is empty or not known.

DisplaySettings class

Environment section: display defaults (track gap, header height, depth scale).

MemberSummary
string ChronostratigraphyRank { get; set; }Chart rank shown as chronostratigraphy zones beside the tops (Period, Epoch, Age ... of the standard / company lexicons); empty: no zones.
float CompressionPower { get; set; }Compressed depth: exponent applied to gaps between features (0-1; lower compresses more).
string DepthScaleMode { get; set; }Default depth scale of new axes: True or Compressed.
float HeaderHeight { get; set; }Minimum track header height (px); tracks may grow it.
float MinGapPx { get; set; }Compressed depth: minimum height of a compressed gap (px).
Measure MinZoomSpan { get; set; }Deepest zoom: the smallest depth span a view shows, converted to each axis's unit (0.5 ft = 0.152 m).
float TrackGap { get; set; }Gap between tracks (px).

EngineeringAttributes class

Engineering attributes shared by strings and components (tally, barrier and sizing input).

MemberSummary
Quantity BurstRating { get; set; }Burst (internal yield) rating — tubulars.
Quantity CollapseRating { get; set; }Collapse rating — tubulars.
string Connection { get; set; }Connection (thread) type.
string Description { get; set; }Description.
Quantity Drift { get; set; }Drift diameter.
Dictionary<string, string> Extra { get; set; }Company-specific attributes (key -&gt; text; quantities as "value unit", dates as yyyy-MM-dd); rules in the environment's equipment section.
string Grade { get; set; }Steel grade.
Quantity InnerDiameter { get; set; }Inside diameter.
bool IsEmpty { get; }True when no attribute is set.
int? JointCount { get; set; }Number of joints.
Quantity Length { get; set; }Length.
string Manufacturer { get; set; }Manufacturer.
string Material { get; set; }Material.
string Model { get; set; }Model.
Quantity OuterDiameter { get; set; }Outside diameter.
string PartNumber { get; set; }Part number.
Quantity PressureRating { get; set; }Pressure rating.
string SerialNumber { get; set; }Serial number.
Quantity TemperatureRating { get; set; }Temperature rating.
Quantity Weight { get; set; }Nominal weight (linear mass), e.g. 47 lbm/ft.

EnvironmentReport static class

Effective settings of an environment as flat rows (path, value, source) and differences between environments.

MemberSummary
static List<(string, string, string)> Diff(WellboreEnvironment a, WellboreEnvironment b)Settings whose effective values differ: (path, value in a, value in b).
static List<Row> Flatten(WellboreEnvironment env, string section = null)Every leaf setting of env (lists and values as JSON), optionally only under section.

EquipmentIssue class

A problem with an equipment attribute (codes WE001-WE005).

MemberSummary
EquipmentIssue(EquipmentIssueSeverity severity, string code, string message, string itemId, string key)Creates an issue: severity, code, message, item and attribute.
string Code { get; }Stable code (WE001...).
string ItemId { get; }Id of the component or equipment.
string Key { get; }Attribute key.
string Message { get; }What is wrong.
EquipmentIssueSeverity Severity { get; }How serious the issue is.
string ToString()Severity, code and message on one line.

EquipmentIssueSeverity enum

Severity of an equipment attribute issue.

MemberSummary
InfoInformation.
WarningShould be reviewed.
ErrorThe value cannot be used.

EquipmentRules static class

Equipment attributes by rule (environment equipment.attributes): the rules of a component type, values by key (built-in typed fields or company keys in Extra), display text, and validation.

MemberSummary
static string Display(EngineeringAttributes a, string key, string unit = null, string componentType = null)Display text: quantities in unit (else the rule's unit, else as stored), other values as stored.
static IReadOnlyList<AttributeRule> For(string componentType)The rules for a component type: "*", then matching prefix rules ("PACKER_*"), then the exact type; later rules replace earlier ones with the same key.
static Quantity ParseQuantity(string text)Parses "5000 psi" / "5000psi" into a quantity (known unit required).
static Quantity Quantity(EngineeringAttributes a, string key)A quantity attribute by key (built-in typed field, or an Extra value written "value unit").
static string Text(EngineeringAttributes a, string key)The attribute as stored text (quantities as "value unit"), or null when not set.
static List<EquipmentIssue> Validate(IEnumerable<(string, string, string, EngineeringAttributes)> items)Validates every component of a model.
static List<EquipmentIssue> Validate(WellModel model)Validates every component of a model.

EquipmentSettings class

Environment section: equipment attribute rules by component type and the completion tally columns.

MemberSummary
Dictionary<string, List<AttributeRule>> Attributes { get; set; }Attribute rules by component type code; "*" applies to all, "PACKER_*" to every code starting with PACKER_.
List<TallyColumnSpec> ProgramColumns { get; set; }Casing and tubing program columns, in order: no, name, top, bottom, hole, od, id, weight, grade, connection, toc, source.
List<string> ProgramExcludedSymbols { get; set; }String symbols left out of the casing and tubing program (control lines...).
List<TallyColumnSpec> TallyColumns { get; set; }Completion tally columns, in order (a list in an overlay replaces this one).

ErrorFormula class

A weighting-function formula as the ISCWSA / OWSG error models write them ("Sin(AzT) / (EarthRate * Cos(Latitude) * Cos(Inc))"): numbers, variables (case-insensitive), + - * / ^, unary minus, parentheses and the functions Sin, Cos, Tan, Abs, Sqr / Sqrt, Max, Min. An unknown variable or function is an error, never a silent zero.

MemberSummary
bool IsZero { get; }True when the formula is the constant 0 (the term has no effect in that direction).
string Text { get; }The formula text.
IReadOnlyCollection<string> Variables { get; }Variable names the formula uses (lower case).
double Evaluate(IReadOnlyDictionary<string, double> variables)Evaluates with variable values by (case-insensitive) name; an unknown name throws KeyNotFoundException.
static ErrorFormula Parse(string text)Parses a formula; throws FormatException on a syntax error.

ErrorSource class

One survey error source (ISCWSA structure): its size, how it affects a station (weight) and how it propagates between stations (random: independent per station; systematic: the same along a survey; global: the same everywhere).

MemberSummary
string Code { get; set; }Short code (DSF, SAG...).
string Description { get; set; }What the error is.
double Magnitude { get; set; }One-sigma size, in Unit.
string Mode { get; set; }random, systematic or global.
string Unit { get; set; }Unit of the magnitude: a length unit (depth), "ratio" (depth scale) or "deg" (angles).
string Weight { get; set; }How the error affects a station: depth, depthScale (x MD), inclination, inclinationSin (x sin I), azimuth.

FieldChange class

One field that differs between two versions of the same item: field name, old value and new value.

MemberSummary
FieldChange(string field, string oldValue, string newValue)Creates a field change: field name, value before and after.
string Field { get; }Field that changed.
string New { get; }Value after.
string Old { get; }Value before.
string ToString()Field, old and new value on one line.

FilesSettings class

Environment section: reading text files from anywhere.

MemberSummary
Dictionary<string, string> EncodingAliases { get; set; }Other names for encodings (cp1251 -&gt; windows-1251...).
string LegacyEncoding { get; set; }Code page for text files that are neither marked (BOM) nor valid UTF-8: windows-1252 (Western), windows-1251 or cp866 (Cyrillic), gbk (Chinese), shift_jis, windows-1256 (Arabic)...

FixedClock class

A clock that always reads the same time (or advances by a fixed step on every read), for deterministic runs.

Inherits / implements: IClock

MemberSummary
FixedClock(DateTime utc, TimeSpan step = null)A clock reading utc, advancing by step after each read (zero: never).
DateTime UtcNow { get; }The current time (UTC).

FluidType enum

Formation fluid typed from its pressure gradient.

MemberSummary
GasGas gradient.
OilOil gradient.
WaterWater gradient.
UnknownGradient outside the configured fluid ranges.

FormationTop class

A formation top or fluid-contact pick at a measured depth, with its canonical stratigraphic unit when known.

Inherits / implements: WellRecord

MemberSummary
string ContactType { get; set; }When set, this pick is a fluid contact (GOC, OWC, GWC, FWL, GDT, ODT, OUT, WUT) rather than a formation top.
Quantity Depth { get; set; }Measured depth of the top.
string Interpreter { get; set; }Who picked the top.
string Lithology { get; set; }Optional lithology code for the interval below this top (shared lithology library).
string Name { get; set; }Top name as picked (company or country name).
string UnitId { get; set; }Canonical stratigraphic unit (lexicon id) this top belongs to; Name keeps the source's own name.

FreeFluidLevel class

Intersection of two gradient lines — a free-fluid level (not a log contact: capillary transition lies above it).

MemberSummary
GradientFit Lower { get; set; }The lower (heavier) fluid's gradient.
string Name { get; set; }Name, for example "Oil / Water".
double Pressure { get; set; }Pressure at the intersection (psi).
double Tvd { get; set; }TVD of the intersection (analysis unit).
double Tvdss { get; set; }TVDSS of the intersection.
GradientFit Upper { get; set; }The upper (lighter) fluid's gradient.

GasCharacter enum

Fluid character interpreted from mud-gas ratios (Haworth et al. 1985).

MemberSummary
BackgroundBackground gas (no show).
VeryDryGasVery dry gas.
GasGas.
GasWithOilGas with oil.
OilOil.
ResidualOilResidual oil.

GasRatios static class

Haworth, Sellens &amp; Whittaker (1985, AAPG Bulletin 69(8)) light-gas ratios and a SCREENING fluid interpretation: Wh = (C2+C3+C4+C5)/(C1..C5) x 100, Bh = (C1+C2)/(C3+C4+C5), Ch = (C4+C5)/C3. Wh 0.5-17.5 gas (Ch &lt; 0.5 confirms gas, &gt; 0.5 gas associated with oil), 17.5-40 oil, &gt; 40 residual oil, &lt; 0.5 very dry gas. Ratios are meaningful only in a show: readings with total gas below minShowGas are Background.

MemberSummary
static double? Balance(GasReading r)Haworth balance Bh = (C1+C2) / (C3+C4+C5); null when the denominator is zero.
static double? Character(GasReading r)Haworth character Ch = (C4+C5) / C3; null without propane.
static GasCharacter Classify(GasReading r, double? minShowGas = null)Screening character with the environment's Haworth bands and show threshold (defaults 0.5 / 17.5 / 40, Ch 0.5, 1000).
static double? Wetness(GasReading r)Haworth wetness Wh = (C2+C3+C4+C5) / sum x 100; null without gas.

GasRatioSettings class

Environment section: Haworth ratio bands and the show-gas threshold.

MemberSummary
double CharacterOilThreshold { get; set; }Haworth: character (Ch) at or above which gas is associated with oil.
double GasWetnessMax { get; set; }Haworth: upper wetness of the gas band.
double MinShowGas { get; set; }Minimum total gas for ratios to be interpreted (below: background).
double OilWetnessMax { get; set; }Haworth: upper wetness of the oil band (above: residual oil).
double VeryDryGasWetness { get; set; }Haworth: wetness (Wh) below this is very dry gas.

GasReading class

One mud-gas chromatograph reading: total gas and C1-C5 (ppm).

Inherits / implements: WellRecord

MemberSummary
double C1 { get; set; }Methane (ppm or %, as recorded).
double C2 { get; set; }Ethane.
double C3 { get; set; }Propane.
double C4 { get; set; }Butanes.
double C5 { get; set; }Pentanes.
Quantity Md { get; set; }Measured depth of the reading.
double Sum { get; }Total C1-C5.
double? TotalGas { get; set; }Total gas in the unit's own scale (gas units / %); null = use C1-C5 sum.

GradientFit class

A fitted pressure gradient: p = Intercept + Gradient x TVD (psi, TVD in the analysis unit).

MemberSummary
int Count { get; set; }Number of tests in the fit.
FluidType Fluid { get; set; }Fluid type from the gradient.
double Gradient { get; set; }psi per analysis length unit (psi/ft or psi/m).
double Intercept { get; set; }Pressure at TVD 0 of the fitted line (psi).
double R2 { get; set; }Coefficient of determination of the fit (near 1 even for mixed fluids; see RmsResidual).
double RmsResidual { get; set; }RMS residual in psi — the meaningful fit quality (testers resolve ~1 psi; R2 is near 1 even for mixed fluids).
double TvdBottom { get; set; }Deepest TVD of the tests (analysis unit).
double TvdTop { get; set; }Shallowest TVD of the tests (analysis unit).
string Zone { get; set; }Zone name.
double PressureAt(double tvd)Pressure (psi) on the fitted line at a TVD (analysis unit).

GrowingLogRows class

New rows of a growing log (index in IndexUnit; values aligned with Mnemonics).

MemberSummary
string IndexUnit { get; set; }Unit of the index.
List<string> Mnemonics { get; set; }Mnemonics of the value columns, in row order.
List<(double, double?[])> Rows { get; set; }New rows: index and one value per mnemonic (null = missing).

GuidIdGenerator class

Random ids (32 hex digits).

Inherits / implements: IIdGenerator

MemberSummary
static GuidIdGenerator Instance { get; }The shared instance.
string NewId()A new id.

HistorySettings class

Environment section: tolerances for matching items between well states.

MemberSummary
Measure MatchTolerance { get; set; }State comparison: items of the same type within this distance are the same item.
double StringMatchFactor { get; set; }State comparison: tolerance multiplier for strings (long objects).

HoleSection class

A drilled hole section: depth range and bit size.

Inherits / implements: WellRecord

MemberSummary
Quantity BitSize { get; set; }Bit size.
Quantity Bottom { get; set; }Bottom of the section.
Quantity Top { get; set; }Top of the section.
string WellboreId { get; set; }Wellbore the section belongs to.

IClock interface

Contract: the current time. Default: the system clock; FixedClock for deterministic runs.

MemberSummary
DateTime UtcNow { get; }The current time (UTC).

ICodeVocabulary interface

Translates source-system codes (PPDM, Seabed, a company database, a vendor file…) to canonical codes.

MemberSummary
string ToCanonical(string domain, string sourceCode)Canonical code for sourceCode in domain; null when not mapped.

ICountryCatalog interface

Contract: the ready-made country environments a host offers ("extends": "country:XX").

MemberSummary
IReadOnlyList<string> Codes { get; }Country codes, sorted.
bool TryGet(string code, string json)The environment JSON of a country; false when there is none.

ICurveClassifier interface

Log curve family (track), order and style from its mnemonic.

MemberSummary
CurvePresentation Classify(string mnemonic)Family and style of a curve by mnemonic.

IGrowingLogSource interface

A source of rows appended to a log while drilling (WITSML "growing object" semantics): returns the rows after lastIndex (null = from the start). Implementations wrap a transport (WITSML store SOAP / ETP, file tail…).

MemberSummary
Task<GrowingLogRows> FetchAfterAsync(double? lastIndex, CancellationToken cancellationToken = null)Rows with an index after lastIndex (all rows when null); an empty result means nothing new yet.

IIdGenerator interface

Contract: new record ids. Default: random GUIDs; SequentialIdGenerator for deterministic runs (tests, lockstep hosts).

MemberSummary
string NewId()A new id.

IJsonPersistable interface

A configurable part that saves itself as JSON; its type reads the same JSON back (FromJson). Load -&gt; save -&gt; load gives the same part (tested for every part).

MemberSummary
string ToJson()The part as JSON.

ILabelProvider interface

UI texts per culture / company.

MemberSummary
string Get(string key, string fallback)The text for a label key, else fallback.

ILeakPathTemplates interface

Contract: the leak-path networks a host offers and how they are chosen for a barrier set.

MemberSummary
IReadOnlyCollection<string> Networks { get; }Network names.
LeakPathNetwork Build(string network, WellBarrierSet set)Builds a named network on a barrier set (unknown name: an empty network).
string NetworkFor(WellBarrierSet set)The name of the network for a barrier set's well type.

ImageLogSettings class

Environment section: borehole-image normalization and colour levels.

MemberSummary
Measure DynamicWindow { get; set; }Dynamic normalization window.
int Levels { get; set; }Colour levels.
string Normalization { get; set; }Default normalization: Static or Dynamic.

IModelCatalog interface

Contract: the vocabulary of the well model - component types, barrier element types, fluid contact types.

MemberSummary
IReadOnlyList<WbeTypeInfo> BarrierElementTypes { get; }Well barrier element types.
IReadOnlyList<ComponentTypeInfo> ComponentTypes { get; }Component (equipment) types.
IReadOnlyList<ContactTypeInfo> ContactTypes { get; }Fluid contact types.

IscwsaErrorModel static class

ISCWSA / OWSG survey error model (the formulation of SPE 67616 with the Rev 5 terms): each term's weighting function gives its effect on depth, inclination and azimuth; position derivatives turn that into north / east / vertical errors, summed as random, systematic or global terms.

MemberSummary
const double EarthRate = 15.041067Earth rotation rate in deg/hr (WGS84: 7.292115e-5 rad/s), rounded to six decimals; the engine uses the exact value.
static ToolErrorResult Compute(IReadOnlyList<(double, double, double)> stations, string depthUnit, SurveyErrorContext context, ToolErrorModel model, IReadOnlyList<double> tvd = null)Covariances for survey stations (md, inclination, azimuth in degrees; md in depthUnit). Computed in SI; results in depthUnit squared. tvd: station TVDs when the survey gives them (else computed by minimum curvature) - used by the depth-stretch term.
static ToolErrorResult Compute(IReadOnlyList<(double, double, double)> stations, string depthUnit, SurveyErrorContext context, IReadOnlyList<(double, ToolErrorModel)> program, IReadOnlyList<double> tvd = null)Covariances for survey stations (md, inclination, azimuth in degrees; md in depthUnit). Computed in SI; results in depthUnit squared. tvd: station TVDs when the survey gives them (else computed by minimum curvature) - used by the depth-stretch term.
static bool IsCorrelatedGeomagnetic(string code)Whether an error code is one of the geomagnetic terms correlated between wells (the supplement's -CH, -CI, -OS, -OH, -OI terms).

IStratigraphicLexicon interface

Maps layer names that differ by company or country to canonical units.

MemberSummary
string DisplayName(StratigraphicUnit unit, string culture)Display name of a unit for a culture: exact culture, then the same language (either direction), then the canonical name.
StratigraphicUnit Resolve(string name)The unit a formation-top name refers to, or null.

ISymbolResolver interface

Canonical component type -&gt; schematic symbol id.

MemberSummary
string SymbolFor(string componentType)The symbol id for a component type, or null to use the built-in mapping.

ItemStatus enum

Lifecycle state of an installed item.

MemberSummary
UnknownStatus not recorded.
PlannedPlanned.
InstalledInstalled.
RemovedRemoved (kept for history).
AbandonedAbandoned in hole.

IUnitCatalog interface

Contract: the units a host knows (symbols and aliases). Units converts through the current services' catalog.

MemberSummary
IReadOnlyCollection<string> Symbols { get; }The canonical symbols.
bool TryFind(string uom, UnitEntry unit)The unit for a symbol or alias; false when unknown.

JsonCodeVocabulary class

JSON vocabulary: { "name": "...", "domains": { "componentType": { "PKR": "PACKER_PERMANENT" }, ... } } (case-insensitive).

Inherits / implements: ICodeVocabulary, IJsonPersistable

MemberSummary
string Name { get; }Name used in warnings (the file name when loaded from a file).
void Add(string domain, string source, string canonical)Adds a mapping from a source code to its canonical value in a domain (codes are case-insensitive).
static JsonCodeVocabulary FromJson(string json)Reads a vocabulary: { "name": ..., "domains": { domain: { source code: canonical } } }.
string ToCanonical(string domain, string sourceCode)The canonical value of a source code in a domain, or null when not mapped.
string ToJson()The vocabulary as JSON (name and domains), readable by String).
static List<ConfigIssue> Validate(string json)Checks a vocabulary file: unknown domains (WR010), invalid canonical values (WR011), case-only duplicate codes (WR012).

JsonCountryCatalog class

Country catalog held as JSON documents by code; the built-in one holds the 62 embedded country files. Loads and saves as one JSON map.

Inherits / implements: ICountryCatalog, IJsonPersistable

MemberSummary
JsonCountryCatalog(IReadOnlyDictionary<string, string> countries)A catalog of country environment JSON documents by ISO code.
static JsonCountryCatalog BuiltIn { get; }The 62 country files embedded in this library.
IReadOnlyList<string> Codes { get; }Country codes, sorted.
static JsonCountryCatalog FromJson(string json)Reads a catalog: { "CODE": { country environment }, ... }.
string ToJson()The catalog as JSON: { "CODE": { country environment }, ... }, readable by String).
bool TryGet(string code, string json)The environment JSON of a country; false when there is none.

JsonLabelProvider class

JSON labels: { "culture": "nb-NO", "labels": { "track.depth": "Dybde" } }; unknown keys return the fallback.

Inherits / implements: ILabelProvider, IJsonPersistable

MemberSummary
string Culture { get; }Culture of the labels (information).
static JsonLabelProvider FromJson(string json)Reads labels: { "culture": ..., "labels": { key: text } }.
string Get(string key, string fallback)The configured text for a key, else fallback.
void Set(string key, string text)Sets the text of a label key.
string ToJson()The labels as JSON (culture and labels), readable by String).
List<ConfigIssue> Validate()Checks a labels file: empty texts (WR020).

JsonLeakPathTemplates class

Leak-path networks held as JSON: { "networks": { name: definition }, "selection": [ rules ], "default": name }. The built-in file is embedded (leak-path-networks.json); companies merge their own by network name (resources.leakPathFiles).

Inherits / implements: ILeakPathTemplates, IJsonPersistable

MemberSummary
static JsonLeakPathTemplates BuiltIn { get; }The networks embedded in this library.
string Default { get; set; }Network when no rule matches.
Dictionary<string, LeakNetworkDefinition> Definitions { get; set; }Networks by name.
IReadOnlyCollection<string> Networks { get; }Network names.
List<LeakNetworkSelection> Selection { get; set; }Selection rules, first match wins.
LeakPathNetwork Build(string network, WellBarrierSet set)Builds a named network on a barrier set (unknown name: an empty network).
static JsonLeakPathTemplates FromJson(string json)Reads networks: { "networks": { ... }, "selection": [ ... ], "default": ... } (a company file may give only networks).
JsonLeakPathTemplates Merge(JsonLeakPathTemplates other)These networks with other's added; a network with the same name replaces this one's; its selection rules come first.
string NetworkFor(WellBarrierSet set)The name of the network for a barrier set's well type.
string ToJson()The networks as JSON, readable by String).

JsonModelCatalog class

Model catalog held as JSON: { "componentTypes": [...], "barrierElementTypes": [...], "contactTypes": [...] }. The built-in one is embedded (model-catalog.json); companies merge their own files over it by code (resources.modelCatalogFiles).

Inherits / implements: IModelCatalog, IJsonPersistable

MemberSummary
JsonModelCatalog(IEnumerable<ComponentTypeInfo> componentTypes, IEnumerable<WbeTypeInfo> barrierElementTypes, IEnumerable<ContactTypeInfo> contactTypes)A catalog of the given types.
IReadOnlyList<WbeTypeInfo> BarrierElementTypes { get; }Well barrier element types.
static JsonModelCatalog BuiltIn { get; }The catalog embedded in this library.
IReadOnlyList<ComponentTypeInfo> ComponentTypes { get; }Component (equipment) types.
IReadOnlyList<ContactTypeInfo> ContactTypes { get; }Fluid contact types.
static JsonModelCatalog FromJson(string json)Reads a catalog (any of the three lists may be missing: a company file adding only what it needs).
JsonModelCatalog Merge(IModelCatalog other)This catalog with other's entries added; an entry with the same code replaces this one's (in place).
string ToJson()The catalog as JSON, readable by String).

JsonStratigraphicLexicon class

JSON lexicon: { "name", "stripPrefixes": ["Top ", "Base "], "units": [ { "id", "name", "aliases", "localNames", "lithology", "color" } ] }.

Inherits / implements: IStratigraphicLexicon, IJsonPersistable

MemberSummary
List<(string, string, string)> Collisions { get; }Names claimed by two different units (the first unit keeps the name).
List<string> StripPrefixes { get; }Prefixes ignored when resolving (e.g. "Top ", "Base "), so "Top Draupne" finds the Draupne unit.
List<StratigraphicUnit> Units { get; }The units of the lexicon.
void Add(StratigraphicUnit u)Adds a unit and indexes its id, name, aliases and local names; a name already claimed by another unit is recorded as a collision, not overwritten.
string DisplayName(StratigraphicUnit unit, string culture)The unit's name in culture (falling back through the parent language to the official name).
static JsonStratigraphicLexicon FromJson(string json)Reads a lexicon: { "stripPrefixes": [...], "units": [ { id, name, aliases, ... } ] }.
StratigraphicUnit Resolve(string name)The unit a formation-top name refers to (after prefix stripping, case- and punctuation-insensitive), or null.
string ToJson()The lexicon as JSON (prefixes to strip and units), readable by String).
List<ConfigIssue> Validate()Checks a lexicon: unit without id (WR001) or name (WR002), duplicate ids (WR003), a name claimed by two units (WR004), invalid colours (WR005).

JsonSymbolResolver class

component-symbols JSON: { "types": { "PACKER_PERMANENT": "pk_permanent", ... } }; null for unmapped types (callers fall back).

Inherits / implements: ISymbolResolver, IJsonPersistable

MemberSummary
static JsonSymbolResolver FromJson(string json)Reads a symbol mapping file ({ "symbols": { "&lt;component type&gt;": "&lt;symbol id&gt;" } }).
void Set(string componentType, string symbolId)Maps a component type to a symbol id.
string SymbolFor(string componentType)The symbol id configured for a component type, or null to use the built-in mapping.
string ToJson()The map as JSON: the document it was read from (all keys kept) with the current component types, readable by String).

JsonUnitCatalog class

Unit catalog from unit definitions (environment units.definitions); loads and saves the definitions as JSON.

Inherits / implements: IUnitCatalog, IJsonPersistable

MemberSummary
JsonUnitCatalog(IReadOnlyDictionary<string, UnitDefinition> definitions)A catalog of definitions (symbol -&gt; definition); definitions with an unknown dimension are left out (environment validation reports them).
JsonUnitCatalog(IReadOnlyDictionary<string, UnitDefinition> definitions, IReadOnlyDictionary<string, string> aliases)A catalog of definitions (symbol -&gt; definition); definitions with an unknown dimension are left out (environment validation reports them).
IReadOnlyCollection<string> Symbols { get; }The canonical symbols.
static JsonUnitCatalog For(UnitSettings settings)The catalog of an environment's unit settings (built once per settings instance).
static JsonUnitCatalog FromJson(string json)Reads definitions: { "symbol": { "dimension": ..., "factor": ..., "offset": ..., "aliases": [...] } }.
string ToJson()The definitions as JSON (symbol -&gt; dimension, factor, offset, aliases), readable by String).
bool TryFind(string uom, UnitEntry unit)The unit for a symbol or alias; false when unknown.

LayeredLabels class

First provider that has a label wins.

Inherits / implements: ILabelProvider

MemberSummary
LayeredLabels(IEnumerable<ILabelProvider> layers)Layers the label providers in precedence order (first match wins).
List<ILabelProvider> Layers { get; }The label providers in precedence order.
string Get(string key, string fallback)The text from the first provider that defines the key, else fallback.

LayeredLexicon class

First lexicon that resolves a name wins.

Inherits / implements: IStratigraphicLexicon

MemberSummary
LayeredLexicon(IEnumerable<IStratigraphicLexicon> layers)Layers the lexicons in precedence order (first match wins).
List<IStratigraphicLexicon> Layers { get; }The lexicons in precedence order (the first that resolves a name wins).
string DisplayName(StratigraphicUnit unit, string culture)The display name from the first lexicon.
StratigraphicUnit Resolve(string name)The unit from the first lexicon that resolves the name, or null.

LayeredVocabulary class

First vocabulary that maps a code wins (data source first, then environment files).

Inherits / implements: ICodeVocabulary

MemberSummary
LayeredVocabulary(IEnumerable<ICodeVocabulary> layers)Layers the vocabularies in precedence order (first match wins).
List<ICodeVocabulary> Layers { get; }The vocabularies in precedence order (the first that maps a code wins).
string ToCanonical(string domain, string sourceCode)The canonical value from the first layer that maps the code, or null.

LeakCavity class

A pressure-containing volume in the well (reservoir, tubing bore, annulus…) or the surroundings.

MemberSummary
string Id { get; set; }Cavity id, referenced by the edges.
CavityKind Kind { get; set; }Source, cavity or sink.
string Label { get; set; }Display label.
double? X { get; set; }Optional diagram position hint (0-1 across / down); null = automatic layout.
double? Y { get; set; }Vertical position in the diagram (0-1); null = automatic.

LeakChainDefinition class

A chain network (permanent abandonment): source, one bore cavity between consecutive envelopes, sink; every element of an envelope links its two cavities.

MemberSummary
string CavityIdPrefix { get; set; }Id prefix of the cavities between envelopes (numbered from 1).
string CavityLabel { get; set; }Label of a cavity between envelopes; {role} is the envelope below it (lower case).
List<string> Roles { get; set; }Envelopes in order from the source (those present in the set are used).
LeakCavity Sink { get; set; }The sink cavity.
LeakCavity Source { get; set; }The source cavity.
double Width { get; set; }Diagram width over which the cavities are spread.
double X0 { get; set; }Diagram x of the source; cavities are spread over Width after it.
double Y { get; set; }Diagram y of the cavities between envelopes.

LeakEdge class

A connection between two cavities: a barrier element (by id in the barrier set) or an open connection (no element). Undirected: a leak can cross it either way.

MemberSummary
string A { get; set; }Id of one cavity.
string B { get; set; }Id of the other cavity.
string ElementId { get; set; }Barrier element id; null = open connection (perforations, open hole…).
string Label { get; set; }Display label (usually the element name).

LeakLinkDefinition class

A link of a leak-path network: every barrier element of Type (in envelope Role, or any) joins cavity A to cavity B.

MemberSummary
string A { get; set; }Cavity on one side.
string B { get; set; }Cavity on the other side.
string Role { get; set; }Envelope (Primary, Secondary, Environmental); null = any envelope.
string Type { get; set; }Barrier element type.

LeakNetworkDefinition class

A named leak-path network: fixed cavities and edges plus links to barrier elements, or a chain; may be based on another network.

MemberSummary
string BasedOn { get; set; }Network this one starts from (its cavities, edges and links), or null.
List<LeakCavity> Cavities { get; set; }Cavities.
LeakChainDefinition Chain { get; set; }A chain instead of fixed cavities (permanent abandonment).
List<LeakEdge> Edges { get; set; }Edges that do not depend on the barrier set (for example open perforations).
List<LeakLinkDefinition> Links { get; set; }Links to the barrier set's elements.
string Notes { get; set; }Notes shown with the network.

LeakNetworkSelection class

Chooses a network for a barrier set: the first rule whose words appear in the set's phase or well type.

MemberSummary
List<string> Contains { get; set; }Words, any of which selects the network (case-insensitive).
string Network { get; set; }Network name.

LeakPath class

One path from the reservoir to the surroundings through the leak-path network, with the barriers still holding on it.

MemberSummary
int Barriers { get; set; }Elements on the path that still count as barriers.
List<string> Cavities { get; }Cavity ids along the path, source to sink.
List<LeakEdge> Edges { get; }Edges along the path.
List<string> UnverifiedElements { get; }Ids of unverified elements counted on the path.

LeakPathAnalysis static class

Counts, for every simple path from the source (reservoir) to the sink (surroundings), the barrier elements that still hold. Intact and Unverified count (unverified flagged); Impaired counts only if countImpaired; Failed never. The well meets an N-barrier requirement when the weakest path still has N.

MemberSummary
static LeakPathResult Analyze(LeakPathNetwork net, Func<string, BarrierElementStatus?> statusOf, int? required = null, bool? countImpaired = null, int maxPaths = 5000)Finds the paths from source to sink and counts the barriers still holding on each (failed elements never count; impaired ones as configured).

LeakPathNetwork class

Leak-path network (a well barrier diagram): cavities joined by barrier elements.

MemberSummary
List<LeakCavity> Cavities { get; set; }The cavities (one source and one sink at least).
List<LeakEdge> Edges { get; set; }The barrier-element links between cavities.
string Notes { get; set; }Notes shown with the analysis.

LeakPathResult class

Result of a leak-path analysis: every path, the weakest barrier count and whether the requirement is met.

MemberSummary
bool MeetsRequirement { get; }True when paths exist and the weakest has the required barriers.
int MinBarriers { get; set; }Barriers on the weakest path.
List<LeakPath> Paths { get; }The paths found (weakest first, limited in number).
bool ReliesOnUnverified { get; }True if any path's count relies on unverified elements.
int Required { get; set; }Barriers required on every path.
IEnumerable<LeakPath> Weakest { get; }The paths with the fewest barriers.

LithologyLine class

A density-neutron lithology line: from the matrix point (neutron reading at zero porosity, matrix density) to the fluid point.

MemberSummary
string Color { get; set; }Line colour (#rrggbb).
double MatrixDensity { get; set; }Matrix density (g/cm3).
string Name { get; set; }Line name (e.g. Sandstone).
double NeutronAtMatrix { get; set; }Neutron porosity (limestone units, v/v) read in the zero-porosity matrix - tool dependent: take it from your neutron tool's chart.

LiveSettings class

Environment section: real-time display (stale threshold, follow span).

MemberSummary
float FollowSpan { get; set; }Depth span shown in follow mode (axis units).
double StaleAfterSeconds { get; set; }Seconds without new data before a live feed is shown as STALE.
int WitsmlRetries { get; set; }WITSML retries after a transient failure.
double WitsmlRetryDelaySeconds { get; set; }Seconds before the first WITSML retry; doubled for each further retry.
double WitsmlTimeoutSeconds { get; set; }Seconds allowed for one WITSML store request (raise for slow links, e.g. satellite).

LoaderSettings class

Environment section: file loader defaults (LAS index mnemonics, null value).

MemberSummary
double LasDefaultNull { get; set; }LAS null value when the file does not declare NULL.
List<string> LasIndexMnemonics { get; set; }LAS index curve mnemonics, in priority order.
List<double> NullValues { get; set; }Curve sample values that mean "no data" wherever curves are drawn or checked, and the DLIS default (LAS files use their declared NULL).

LocaleSettings class

How numbers and dates look on screen and in printed output; files always stay invariant.

MemberSummary
string Calendar { get; set; }Calendar of dates on screen: Gregorian (default - also for cultures whose own calendar differs, such as ar-SA or th-TH) or Culture.
string Culture { get; set; }Culture for numbers on screen (for example de-DE: decimal comma); empty: invariant (decimal point).
string DateFormat { get; set; }Date pattern on screen (.NET custom format, for example dd.MM.yyyy); empty: the culture's short date.
string DateTimeFormat { get; set; }Date and time pattern on screen; empty: the culture's short date and time.
string TimeZone { get; set; }Time zone for displayed and printed times (IANA or Windows id, e.g. UTC, Europe/Oslo, America/Denver); empty: the machine's own zone. Stored times stay UTC.

LogCurveData class

One curve of a log set: values aligned with the set's index (null = no data).

MemberSummary
string Description { get; set; }Description from the source.
string Mnemonic { get; set; }Curve mnemonic, for example GR.
string Unit { get; set; }Unit as written by the source.
double?[] Values { get; set; }One value per index sample (null = missing).

LogEditing static class

Depth shifting and splicing of log sets - non-destructive: results are new sets, the inputs stay as they are.

MemberSummary
static LogSet DepthShift(LogSet set, IReadOnlyList<(double, double)> ties, IEnumerable<string> mnemonics = null)Shifts curves of a set: tie points map recorded depth to true depth (one point = bulk shift; several = piecewise linear, extrapolated with the end offsets). Shifted curves are resampled onto the set's index (linear); others are copied.
static LogSet Splice(IReadOnlyList<LogSet> runs, SpliceOptions options = null)Splices runs into one composite: runs ordered by top; in each overlap the rule (or a curve's own splice depth) decides which run's data is kept. The index is strictly increasing (no duplicated samples); values come from the chosen run (linear interpolation if its sampling differs). Runs must share the index unit (converted otherwise).

LogEditSession class

Log edits on a well model with an audit entry for each and undo: an undo restores the previous log set object exactly.

MemberSummary
LogEditSession(WellModel model, string author)Creates a session on a model, auditing as author.
string Author { get; }Who edits (audit).
bool CanUndo { get; }Whether there is an edit to undo.
WellModel Model { get; }The model edited.
LogSet DepthShift(string logSetId, IReadOnlyList<(double, double)> ties, IEnumerable<string> mnemonics = null, string reason = null)Depth-shifts curves of a log set in the model (replaced by the shifted set).
LogSet Splice(IReadOnlyList<string> logSetIds, SpliceOptions options = null, string reason = null)Splices log sets of the model into a new composite set (the runs are kept).
bool Undo()Undoes the last edit (audited as a note); false when there is nothing to undo.

LogIndexType enum

Whether a log set is indexed by depth or by time.

MemberSummary
DepthIndexed by depth.
TimeIndexed by time.

LogSet class

Canonical, format-neutral log data (from WITSML, LAS, DLIS…): an index (depth in IndexUnit, or time) and curves. Presentation families build tracks from it; loaders fill it.

Inherits / implements: WellRecord

MemberSummary
List<LogCurveData> Curves { get; set; }The curves sharing the index.
double[] Index { get; set; }Index values (IndexUnit).
string IndexMnemonic { get; set; }Mnemonic of the index curve.
LogIndexType IndexType { get; set; }Depth or time index.
string IndexUnit { get; set; }Unit of depth indices (canonical symbol, e.g. "m", "ft").
string Name { get; set; }Log set name (file or run).

LogSettings class

Environment section: log curve families, styles and log validation thresholds.

MemberSummary
string FallbackFamily { get; set; }Family for curves matching no rule.
int FallbackOrder { get; set; }Order of the fallback family.
List<CurveFamilyRule> Families { get; set; }Curve families (tracks) and the mnemonics that belong to them; first match wins; unmatched curves go to FallbackFamily.
double GapFactor { get; set; }Validation: a depth step larger than this multiple of the median step is a data gap (WL008).
Measure ImageBoreholeDiameter { get; set; }Hole size assumed for image logs (dip sinusoid amplitude) when the image does not give its own.
double MaxClippedFraction { get; set; }Validation: fraction of values outside the scale above which a curve is flagged (WL009).
Dictionary<string, string> MnemonicAliases { get; set; }Other names for mnemonics (for example Russian ГК / GK -&gt; GR, КС / KS -&gt; RES): the curve is grouped and styled as the canonical mnemonic. Used for tracks and styles only, never as a petrophysics input (a neutron-gamma count log is not neutron porosity).
List<CurveStyleRule> Styles { get; set; }Curve styles; first matching rule wins.

MaaspLimit class

One limiting pressure in a MAASP screening.

MemberSummary
MaaspLimit(string name, double psi, string basis)Creates a limit: name, value in psi and the basis of the calculation.
string Basis { get; }How it was obtained (inputs, factors) — shown to the user.
string Name { get; }Name of the limit (for example the weakest element).
double Psi { get; }Limit in psi.

MaaspScreening static class

MAASP SCREENING estimate (not a design calculation). Surface-point simplifications: outer casing burst x derating, inner string collapse x derating, formation at the outer shoe = (fracture gradient − annulus fluid gradient) x shoe TVD, wellhead / hanger rating. The lowest limit governs. ISO 16530-1 and API RP 90 require a full analysis (depth-dependent loads, backup fluids, temperature, wear); use this to flag, not to set, limits.

MemberSummary
static MaaspLimit Governing(IEnumerable<MaaspLimit> limits)Governing (lowest) limit, or null without inputs.
static double? Gradient(Quantity q)Pressure gradient in psi/ft from any pressure-gradient unit of the catalogue (psi/ft, kPa/m, bar/m, MPa/m ...) or a density (equivalent mud weight).
static List<MaaspLimit> Limits(AnnulusInfo annulus, EngineeringAttributes inner, EngineeringAttributes outer, Quantity outerShoeTvd, double? burstDerating = null, double? collapseDerating = null)Limits with the environment's deratings (defaults: burst 0.8, collapse 1.0) unless given.

MagneticFieldValues class

Magnetic field at a place and time.

MemberSummary
double Declination { get; set; }Declination (degrees, east positive).
double Down { get; set; }Down component Z (nT).
double East { get; set; }East component Y (nT).
double Horizontal { get; set; }Horizontal intensity H (nT).
double Inclination { get; set; }Inclination / dip (degrees, down positive).
string Model { get; set; }Model name (for example WMM-2025).
double North { get; set; }North component X (nT).
bool OutsideLifeSpan { get; set; }True when the date is outside the model's life span (an extrapolation the model's authors do not support).
double TotalField { get; set; }Total field strength F (nT).

MagneticReference static class

The field and reference values of a well for its survey error model: the header's values, else the geomagnetic model at the well.

MemberSummary
static SurveyErrorContext ForWell(WellHeader h, string azimuthReference, List<string> warnings = null)The context for a well's survey error model; null when the field is unknown and cannot be computed (no location). Header values win; missing ones come from the services' geomagnetic model at the well's latitude / longitude, datum elevation and survey date (today when none, said in the warnings). azimuthReference: the north the station azimuths refer to (True or Grid).
static double NormalGravity(double latitude)WGS84 normal gravity at a geodetic latitude (Somigliana formula, m/s2).

MapSettings class

Environment section: well map (plan view) colours and grid.

MemberSummary
string PathColor { get; set; }Plan-view well path colour.
float PickRadius { get; set; }Pixel radius within which a click selects a well.
string SectionLineColor { get; set; }Section line colour.
bool ShowGrid { get; set; }Draw a coordinate grid.
string WellColor { get; set; }Well surface location marker colour.

Measure class

A value with a unit, as written in environment files: { "value": 10, "unit": "ft" }.

MemberSummary
Measure()An empty measure (for deserialization).
Measure(double value, string unit)A value with its unit.
string Unit { get; set; }Unit symbol, e.g. ft, m, psi, psi/ft, kPa/m.
double Value { get; set; }Numeric value.
double In(string unit)The value in unit (unit conversion through the canonical unit registry).
Quantity ToQuantity()The value as a Quantity.
string ToString()Value and unit.

MnemonicMatch class

Pattern test on a curve mnemonic (case-insensitive); any listed condition matching is a match.

MemberSummary
List<string> Contains { get; set; }Mnemonic contains any of these.
List<string> Exact { get; set; }Mnemonic equals any of these.
string Family { get; set; }Matches curves already classified into this family.
List<string> StartsWith { get; set; }Mnemonic starts with any of these.

ModelAudit static class

The audit trail of a well (Audit): record changes between two versions of a model, log single changes, query the history of an item or a time range, export as CSV. Entries are appended, never rewritten.

MemberSummary
static List<AuditEntry> Between(WellModel model, DateTime fromUtc, DateTime toUtc)The entries between two times (inclusive, UTC), oldest first.
static List<AuditEntry> History(WellModel model, string entityId)The entries of one item, oldest first.
static AuditEntry Latest(WellModel model, string entityId)The most recent entry of an item, or null.
static AuditEntry Log(WellModel model, AuditEntry entry)Appends one entry (time set when missing) and returns it.
static List<AuditEntry> Record(WellModel before, WellModel after, string author, string reason = null, DateTime? utc = null, string source = null)Records the differences between before and after (strings, components, intervals and the other items the well-state comparison covers, all statuses) in after's audit; returns the new entries.
static string ToCsv(IEnumerable<AuditEntry> entries)Entries as RFC 4180 CSV (utc, author, action, type, id, label, field, before, after, reason, source).

ModelCatalog static class

The model catalog in effect: the current services' (ModelCatalog), else the built-in one.

MemberSummary
static IModelCatalog Current { get; }The catalog in effect.
static ContactTypeInfo Contact(string code)The contact type of a code in the catalog in effect, or null.

ModelIssue class

A finding about a well model (code, severity, message, the record concerned).

MemberSummary
ModelIssue(ModelIssueSeverity severity, string code, string message, string entityId = null)Creates an issue.
string Code { get; }Code (for example WI001).
string EntityId { get; }Record concerned, if any.
string Message { get; }Message.
ModelIssueSeverity Severity { get; }Severity.
string ToString()"severity CODE: message" (the form load results list).

ModelIssueSeverity enum

Severity of a model issue.

MemberSummary
InfoInformation.
WarningProbably wrong; the data is still usable.
ErrorWrong.

NorthCorrection static class

Corrects survey azimuths from the well's survey north (magnetic / true / grid) to the environment's working north: magnetic to true adds the declination; true to grid subtracts the convergence (east-positive convention, configurable). A correction that needs a missing value is reported and left out, never guessed.

MemberSummary
static double Apply(double azimuth, double correction)An azimuth plus a correction, in [0, 360).
static double Degrees(WellHeader header, List<string> warnings = null)Degrees to add to the well's survey azimuths to refer them to the working north; warnings name any missing value.
static double Degrees(WellHeader header, NorthReference from, List<string> warnings = null)Degrees to add to azimuths referred to from to refer them to the working north (declination, grid convergence from the header).

NorthReference enum

North a direction refers to.

MemberSummary
GridGrid north of the map projection.
TrueTrue (geographic) north.
MagneticMagnetic north.

NullContracts static class

Null objects: never break a view when a contract is not configured.

MemberSummary
static ILabelProvider LabelsA label provider without labels (built-in texts are used).
static IStratigraphicLexicon LexiconAn empty lexicon.
static ISymbolResolver SymbolsA symbol resolver without mappings (built-in symbols are used).
static ICodeVocabulary VocabularyA vocabulary that maps nothing.

OffsetSeparation class

The scan of one offset well.

MemberSummary
SeparationPoint Closest { get; }The point of closest approach.
SeparationPoint Minimum { get; }The point with the lowest separation factor.
string Name { get; set; }Offset well name.
List<SeparationPoint> Points { get; }Scan points, reference MD order.

OsduSettings class

Environment section: OSDU export - the data partition and the access / legal metadata every OSDU record needs (deployment-specific; no defaults).

MemberSummary
List<string> Countries { get; set; }Other relevant data countries (ISO 3166 two-letter); none: the environment's country.
string DataPartition { get; set; }Data partition id: the namespace of record and reference-data ids (e.g. "opendes").
List<string> LegalTags { get; set; }Legal tags of the records.
List<string> Owners { get; set; }ACL owner groups.
List<string> Viewers { get; set; }ACL viewer groups (e.g. data.default.viewers@opendes.yourcompany.com).

PaperDefinition class

A paper size in points (1/72 inch), portrait.

MemberSummary
float Height { get; set; }Height (points).
float Width { get; set; }Width (points).

PayCutoffs class

Pay cutoffs: a sample is net reservoir when Vsh &lt;= vshMax and porosity &gt;= porosityMin, net pay when also Sw &lt;= swMax (unset = not applied).

MemberSummary
double? PorosityMin { get; set; }Minimum porosity (v/v) of net reservoir.
double? SwMax { get; set; }Maximum water saturation (v/v) of net pay.
double? VshMax { get; set; }Maximum shale volume (v/v) of net reservoir.
PayCutoffs Over(PayCutoffs fallback)These cutoffs with unset fields taken from fallback.
string ToString()"Vsh &lt;= 0.4, PHI &gt;= 0.1, Sw &lt;= 0.6" or "none".

PaySummary static class

Pay summary (gross, net reservoir, net pay, averages) per zone between formation tops, with the cutoffs of petrophysics.cutoffs / zoneCutoffs. Sample thickness: half the distance to each neighbour, clipped to the zone.

MemberSummary
static PaySummaryResult Compute(WellModel model, LogSet set = null, List<string> warnings = null, PetrophysicsSettings settings = null)Computes the summary for a log set of the model (default: the first depth-indexed one).
static string ToCsv(PaySummaryResult r)The summary as CSV (invariant numbers), one row per zone.

PaySummaryResult class

Pay summary of a log set over the well's zones.

MemberSummary
string DepthUnit { get; set; }Unit of depths and thicknesses (the log index unit).
string LogSetName { get; set; }The log set it was computed from.
List<PayZone> Zones { get; }Zones, top down.

PayZone class

Pay summary of one zone (between two formation tops); thicknesses in the log index unit.

MemberSummary
double Base { get; set; }Base (MD).
PayCutoffs Cutoffs { get; set; }Cutoffs applied to this zone.
double Gross { get; set; }Zone thickness (MD).
double? GrossTvd { get; set; }Gross thickness in TVD (null without survey).
double HydrocarbonColumn { get; set; }Hydrocarbon column of net pay, sum of h * PHI * (1 - Sw) (index unit).
double Logged { get; set; }Thickness with log values (MD).
string Name { get; set; }Zone (formation) name.
double NetPay { get; set; }Net pay thickness (MD): net reservoir and the Sw cutoff met.
double? NetPayTvd { get; set; }Net pay thickness in TVD (null without survey).
double NetReservoir { get; set; }Net reservoir thickness (MD): Vsh and porosity cutoffs met.
double NetToGross { get; }Net reservoir / gross.
double? Porosity { get; set; }Average porosity of net pay (thickness weighted).
double? Sw { get; set; }Average water saturation of net pay (pore-volume weighted).
double Top { get; set; }Top (MD).
double? Vsh { get; set; }Average shale volume of net pay (thickness weighted).

Petrophysics static class

Textbook petrophysical relations (pure functions). Shale volume from the gamma-ray index (linear, Larionov tertiary / older, Clavier, Steiber); density porosity; density-neutron combination (average or root mean square); Archie water saturation and bulk volume water. Archie assumes clean formations: no shale correction (Simandoux, Indonesia) is applied.

MemberSummary
static double ArchieSw(double phi, double rt, double rw, double a, double m, double n)Archie water saturation Sw = (a Rw / (phi^m Rt))^(1/n), limited to 0-1.
static double? DensityGcc(double value, string unit)Density in g/cm3 from a value and a (LAS or canonical) unit; null when the unit is not a density.
static double DensityNeutronPorosity(double phiD, double phiN, string method)Density-neutron porosity: arithmetic average, or root mean square (reduces the gas effect).
static double DensityPorosity(double rhoBulk, double rhoMatrix, double rhoFluid)Density porosity (rhoMatrix - rhoBulk) / (rhoMatrix - rhoFluid), limited to 0-1 (densities in one unit).
static double GammaRayIndex(double gr, double grClean, double grShale)Gamma-ray index IGR = (GR - GRclean) / (GRshale - GRclean), limited to 0-1.
static double NeutronFraction(double value, string unit)Neutron porosity as a fraction from v/v (dec, frac) or percent (%, pu); unknown units are taken as fractions below 1.
static double ShaleVolume(double igr, string method)Shale volume from the gamma-ray index with method.

PetrophysicsCalculator static class

Computes VSH, PHID, PHIT, SW and BVW for a depth log set with the environment's petrophysics settings. Inputs are found by mnemonic through the curve-mnemonic vocabulary; missing inputs skip only the curves that need them (reported). Output values are null where an input is null.

MemberSummary
static List<string> AddTo(LogSet set, PetrophysicsSettings settings = null)Computes and appends the curves to set (replacing earlier computed curves of the same names).
static List<LogCurveData> Compute(LogSet set, List<string> warnings = null, PetrophysicsSettings settings = null)Computes VSH, PHID, PHIT, SW and BVW for the set without changing it; missing inputs are reported in warnings.
static LogCurveData FindInput(LogSet set, string roleOrMnemonic, PetrophysicsSettings settings = null)The input curve for a role (gammaRay, density, neutron, resistivity) or a mnemonic, through the curve-mnemonic vocabulary.
static double PorosityFraction(double value, string unit)A porosity value as a fraction (v/v): converted from %, pu or any fraction unit; unknown units are taken as v/v.
static double? ResistivityOhmM(double value, string unit)Resistivity in ohm.m from a curve value: any resistivity unit of the catalogue, or a conductivity (mS/m, S/m, mmho/m) as R = 1 / σ (zero / negative conductivity: null); unknown units are taken as ohm.m.

PetrophysicsSettings class

Environment section: parameters of the computed petrophysical curves (shale volume, porosity, Archie saturation).

MemberSummary
double ArchieA { get; set; }Archie tortuosity factor a.
double ArchieM { get; set; }Archie cementation exponent m.
double ArchieN { get; set; }Archie saturation exponent n.
PayCutoffs Cutoffs { get; set; }Pay cutoffs (pay summary): company / field policy - there are no universal values (Worthington 2010), so none by default.
string DensityNeutronMethod { get; set; }Density-neutron combination: Average or RootMeanSquare (gas zones).
Measure FluidDensity { get; set; }Pore fluid density (fresh water 1.0, salt mud filtrate about 1.1 g/cm3).
double GrClean { get; set; }Gamma ray of clean formation (API) - shale volume.
double GrShale { get; set; }Gamma ray of shale (API) - shale volume.
string GrUnit { get; set; }Unit of grClean / grShale (gAPI; uR/h for Russian / CIS gamma-ray logs); GR curves are converted to it where possible.
Dictionary<string, string> Inputs { get; set; }Input curve mnemonics (after the curve-mnemonic vocabulary): gammaRay, density, neutron, resistivity.
Measure MatrixDensity { get; set; }Matrix density (sandstone 2.65, limestone 2.71, dolomite 2.87 g/cm3).
double Rw { get; set; }Formation water resistivity Rw at formation temperature (ohm.m).
string VshMethod { get; set; }Shale volume from the gamma-ray index: Linear, LarionovTertiary, LarionovOlder, Clavier or Steiber.
Dictionary<string, PayCutoffs> ZoneCutoffs { get; set; }Cutoffs per zone (formation name), overriding Cutoffs field by field.

PipeDimension class

A pipe dimension: nominal weight -&gt; wall thickness for one outside diameter (inches, lb/ft).

MemberSummary
double OuterDiameter { get; set; }Outside diameter (in).
double Wall { get; set; }Wall thickness (in).
double Weight { get; set; }Nominal weight (lb/ft).

PressureAnalysis static class

Pressure-depth analysis: least-squares gradients per zone (explicit labels, or optimal automatic segmentation into up to maxZones straight segments), fluid typing from the gradient, and free-fluid levels at line intersections. Typical gradient ranges (psi/ft): gas &lt; 0.20, oil 0.20-0.40, water &gt;= 0.40 — screening, not a PVT substitute.

MemberSummary
static PressureAnalysisResult Analyze(IEnumerable<PressureTest> tests, Func<double, double> toTvd, string unit = null, double datumElevation = 0, int? maxZones = null)Runs the analysis. toTvd converts a test's MD (in unit) to TVD; datumElevation (same unit, above MSL) gives TVDSS for the levels. Pressures are converted to psi.
static FluidType Classify(double psiPerFt)Fluid type from a gradient in psi/ft, with the environment's boundaries (defaults 0.20 / 0.40 psi/ft).
static GradientFit Fit(IReadOnlyList<(double, double)> pts, string zone = "")Least-squares line through (tvd, p).
static double PsiPerFt(Measure m)A gradient setting in psi/ft: any pressure-gradient unit of the catalogue, or a density as equivalent mud weight.
static List<int> Segment(IReadOnlyList<(double, double)> pts, int? maxZones = null, int? minPoints = null, double? improvement = null, double? minGradientContrast = null)Optimal split of TVD-sorted points into k = 1..maxZones straight segments (dynamic programming on squared error), each with at least minPoints points. A further split is kept only if it lowers the error by more than improvement (fraction) AND adjacent segments differ in gradient by at least minGradientContrast (psi per analysis unit; 0.05 psi/ft by default) — error reduction alone would split a single noisy fluid into lines that just fit the noise.

PressureAnalysisResult class

Result of a formation-pressure analysis: gradient fits per zone, fluid types and free-fluid levels.

MemberSummary
List<GradientFit> Gradients { get; }Gradient fits per zone.
List<FreeFluidLevel> Levels { get; }Free-fluid levels between consecutive gradients.
string Unit { get; set; }Depth unit of the analysis.
Dictionary<string, string> ZoneOf { get; }Per valid test: its zone.

PressureQuality enum

Formation tester result quality; only Valid tests enter gradient analysis.

MemberSummary
ValidValid test.
TightTight formation (no stable pressure).
SuperchargedSupercharged (reads above formation pressure).
LostSealLost seal.
NoSealNo seal.
UnknownQuality not recorded.

PressureSettings class

Environment section: fluid-typing boundaries, automatic zoning and fit-quality thresholds.

MemberSummary
Measure GasOilBoundary { get; set; }Gradient below which a fluid is typed as gas.
Measure MaxRmsResidual { get; set; }Gradient fit RMS residual above which a fit is flagged (WL031).
int MaxZones { get; set; }Automatic zoning: maximum number of fluid zones.
Measure MinGradientContrast { get; set; }Automatic zoning: minimum gradient difference between adjacent zones.
int MinPointsPerZone { get; set; }Automatic zoning: minimum tests per zone.
Measure OilWaterBoundary { get; set; }Gradient at or above which a fluid is typed as water.
double SplitImprovement { get; set; }Automatic zoning: a further split must reduce the squared error by at least this fraction.

PressureTest class

One wireline formation pressure test (RFT / MDT / XPT-type).

Inherits / implements: WellRecord

MemberSummary
DateTime? Date { get; set; }Test date.
Quantity Md { get; set; }Measured depth of the test.
double? Mobility { get; set; }Drawdown mobility (e.g. mD/cP), when reported.
Quantity Pressure { get; set; }Formation pressure.
PressureQuality Quality { get; set; }Test quality; only valid tests are used in gradients.
string Tool { get; set; }Tool / service.
string Zone { get; set; }Explicit zone label (e.g. "gas", "oil", "water"); overrides automatic segmentation.

PrintSettings class

Environment section: paper, scale, header block, legend, footer, page templates and raster resolution.

MemberSummary
float Dpi { get; set; }Raster export resolution (dpi).
float FooterHeight { get; set; }Footer height (pt).
string FooterLeft { get; set; }Left footer text; tokens: {well}, {title}, {reference}, {range}, {scale}, {page}, {pages}, {date}.
string FooterRight { get; set; }Right footer text (same tokens).
float HeaderBlockHeight { get; set; }Header block height (pt).
Dictionary<string, string> HeaderFields { get; set; }Extra header-block fields (label -&gt; value), e.g. company, rig, revision.
bool IncludeHeaderBlock { get; set; }Print the well header block on page 1.
bool IncludeLegend { get; set; }Print the legend.
bool Landscape { get; set; }Landscape orientation.
float Margin { get; set; }Page margin (pt).
string Paper { get; set; }Paper: a name from printing.papers (A4, A3, Letter, Tabloid or your own).
Dictionary<string, PaperDefinition> Papers { get; set; }Paper sizes by name in points (portrait); add your own (B4, ANSI C, plotter rolls...).
float ScaleRatio { get; set; }Depth scale 1:N (0 = fit to page).
Dictionary<string, PrintTemplate> Templates { get; set; }Named page templates; a template changes only the settings it names.

PrintTemplate class

A named page template: every setting is optional and overrides the printing defaults only when set.

MemberSummary
string FooterLeft { get; set; }Left footer text (tokens as in printing.footerLeft).
string FooterRight { get; set; }Right footer text.
Dictionary<string, string> HeaderFields { get; set; }Header-block fields added for this template (label -&gt; value).
bool? IncludeHeaderBlock { get; set; }Print the header block on page 1.
bool? IncludeLegend { get; set; }Print the legend.
bool? Landscape { get; set; }Landscape orientation.
float? Margin { get; set; }Page margin (pt).
string Paper { get; set; }Paper: a name from printing.papers (A4, A3, Letter, Tabloid or your own).
float? ScaleRatio { get; set; }Depth scale 1:N (0 = fit to page).
string Title { get; set; }Title printed in the header (null = the document name).

Quantity class

A measured value with its unit of measure. The original unit is kept; convert on demand.

MemberSummary
Quantity()An empty quantity (for deserialization).
Quantity(double value, string uom)A value with its unit of measure.
string Uom { get; set; }Unit of measure as given by the source (canonical symbol when known).
double Value { get; set; }The numeric value, in Uom.
double In(string uom)Value in uom; throws for unknown or incompatible units.
string ToString()Value and unit, for example "8.5 in".
bool TryIn(string uom, double value)Converts to another unit of the same dimension; false when the units are unknown or incompatible.

ReferenceCase class

A known-answer case run by wellbore-config verify: a calculation with its expected result and tolerance. Kinds: unit, trajectory, north, uncertainty (built in); other libraries add kinds (dipSinusoid). Only the fields of the case's kind are used.

MemberSummary
double? AtMd { get; set; }uncertainty: measured depth of the station compared.
double? BoreholeAzimuth { get; set; }dipCorrection: hole azimuth (degrees).
double? BoreholeInclination { get; set; }dipCorrection: hole inclination (degrees).
double? BTotal { get; set; }uncertainty: total magnetic field (nT); with MagneticDip the survey tool model is used (else the simple model).
double? Convergence { get; set; }north: grid convergence.
double? Declination { get; set; }north: magnetic declination.
double? DiameterIn { get; set; }dipSinusoid: borehole diameter (in).
double? Dip { get; set; }dipSinusoid: dip (degrees).
double? DipAzimuth { get; set; }dipSinusoid: dip azimuth (degrees); also the expected azimuth of the deepest point.
string DipAzimuthReference { get; set; }dipCorrection: North or HighSide - what the given and expected relative azimuths are measured from.
string DipFrame { get; set; }dipCorrection: frame of the given pick - True (expected: borehole-relative) or BoreholeRelative (expected: true).
double? Expected { get; set; }unit / north / dipSinusoid: the expected result (converted value, corrected azimuth, peak-to-trough amplitude).
Dictionary<string, int> ExpectedCounts { get; set; }dataSource: expected counts - strings, components, holeSections, intervals, tops, surveyStations, logSets, curves.
List<CurveValueCheck> ExpectedCurveValues { get; set; }dataSource: expected curve values (within Tolerance).
double? ExpectedDipAzimuth { get; set; }dipCorrection: expected azimuth (with Expected the expected dip).
double? ExpectedEast { get; set; }trajectory: expected east of the last station.
string ExpectedName { get; set; }dataSource: the expected well name.
double? ExpectedNorth { get; set; }trajectory: expected north, east and TVD of the last station.
double? ExpectedSigmaEast { get; set; }uncertainty: expected 1-sigma east uncertainty.
double? ExpectedSigmaNorth { get; set; }uncertainty: expected 1-sigma north, east and vertical position uncertainty (for example from an ISCWSA test well).
double? ExpectedSigmaTvd { get; set; }uncertainty: expected 1-sigma vertical uncertainty.
double? ExpectedTvd { get; set; }trajectory: expected TVD of the last station.
string From { get; set; }unit: from unit.
double? Gravity { get; set; }uncertainty: gravity (m/s2); default 9.80665 as in the ISCWSA examples.
string Kind { get; set; }unit, trajectory, north, uncertainty, dipSinusoid.
double? MagneticDip { get; set; }uncertainty: magnetic dip (degrees).
int? MaxWarnings { get; set; }dataSource: most load warnings allowed (0: every code mapped, nothing missing).
string Name { get; set; }Case name (reported).
string Source { get; set; }dataSource: the data source to load (a key of dataSources).
List<double[]> Survey { get; set; }trajectory / uncertainty: survey stations [md, inclination, azimuth].
string SurveyNorth { get; set; }north: survey north (Magnetic, True, Grid).
string To { get; set; }unit: to unit; trajectory / uncertainty / dipSinusoid: length unit of the inputs and results.
double Tolerance { get; set; }Absolute tolerance on every compared value.
string ToolModel { get; set; }uncertainty: tool model name; default the environment's survey.toolModel.
double? Value { get; set; }unit: value to convert; north: survey azimuth.
string WellId { get; set; }dataSource: the well to load (none: the first well of a tabular source).
string WorkingNorth { get; set; }north: working north (Grid, True); default the environment's.

ReferenceCaseResult class

Result of a reference case: pass / fail with each compared value.

MemberSummary
string Error { get; set; }Why the case could not run (missing input, unknown kind), or null.
string Kind { get; set; }Case kind.
string Name { get; set; }Case name.
bool Passed { get; }True when every compared value is within tolerance and the case ran.
List<(string, double, double, double)> Values { get; }Compared values: (quantity, expected, actual, tolerance).
string ToString()One line per result: PASS / FAIL, the case, and each value with its deviation.

ReferenceCases static class

Runs reference cases with the current services (units, north, error model of the environment in scope).

MemberSummary
static List<ReferenceCaseResult> Run(IEnumerable<ReferenceCase> cases, IReadOnlyDictionary<string, Func<ReferenceCase, ReferenceCaseResult>> evaluators = null)Runs the cases; evaluators adds kinds from other libraries (for example dipSinusoid).

RegionSettings class

Environment section: the country or region the environment is for (set by a country preset).

MemberSummary
List<string> CoordinateSystems { get; set; }Coordinate systems commonly used in the country (information; confirm with your survey department).
string Country { get; set; }ISO 3166 two-letter country code (for example US, RU, NO).
string Name { get; set; }Country or region name.
string Notes { get; set; }Notes on the preset (what is typical practice and should be confirmed).
List<string> Regulators { get; set; }Regulators and standards commonly referred to there (information).
List<WellIdentifierFormat> WellIdentifiers { get; set; }Well identifier formats of the country; a well's identifier must match one (WI001). Empty: not checked.

ResourceSettings class

External files overriding built-in resources; paths relative to the environment file.

MemberSummary
List<string> BarrierTemplateFiles { get; set; }Barrier template files merged over the built-in templates by name.
string ComponentSymbolsFile { get; set; }Component type -&gt; symbol JSON (same format as the built-in component-symbols.json).
List<string> CountryFolders { get; set; }Folders with company country environments (&lt;CODE&gt;.json); "country:XX" looks here before the built-in countries.
string GeomagneticModelFile { get; set; }Geomagnetic model coefficient file in NOAA .COF format (for example a newer World Magnetic Model); none: the embedded WMM2025.
List<string> LabelFiles { get; set; }UI label files (per culture / company).
List<string> LeakPathFiles { get; set; }Leak-path network files merged over the built-in networks by name (their selection rules first).
List<string> LexiconFiles { get; set; }Stratigraphic lexicon files (local layer names -&gt; canonical units).
string LithologyFile { get; set; }Lithology library JSON (replaces the built-in library).
List<string> LithologyStandards { get; set; }National lithology standards layered on the library: GOST 21.302-2013 (built in), or a standard JSON file (numbers / names as aliases, the standard's drawings as overrides). FGDC numbers are in the built-in library.
string MappingProfilesFolder { get; set; }Folder searched for data-source mapping profiles (&lt;name&gt;.profile.json) before the built-in ones.
List<string> ModelCatalogFiles { get; set; }Model catalog files (component, barrier element and fluid contact types) merged over the built-in catalog by code.
List<string> StandardLexicons { get; set; }Published stratigraphic standards layered under the lexicon files (built in: ICS - the International Chronostratigraphic Chart); empty: none.
string SymbolCatalogFile { get; set; }Symbol catalog JSON (replaces the built-in catalog).
List<string> ToolModelFiles { get; set; }Survey tool error models as ISCWSA error-model JSON files (from survey contractors); they join survey.toolModels by model name.
List<string> VocabularyFiles { get; set; }Code vocabulary files (source codes -&gt; canonical), first match wins.

RoleDefinition class

Which items play a role: by component type, by symbol id, by symbol id prefix; excluded symbols never match by symbol.

MemberSummary
List<string> ComponentTypes { get; set; }Component types playing the role.
List<string> ExcludeSymbols { get; set; }Symbols that never match by symbol (for example the tubing anchor among pk_ symbols).
List<string> SymbolPrefixes { get; set; }Symbol id prefixes playing the role.
List<string> Symbols { get; set; }Symbol ids playing the role.

Row class

One effective setting: dotted path, JSON value and where it came from (file, preset or "default").

MemberSummary
Row(string path, string value, string source)Creates a row: setting path, JSON value and source.
string Path { get; }Dotted setting path, for example cement.goodBondIndex.
string Source { get; }Where the value came from: a file path, "preset:name" or "default".
string Value { get; }Effective value as JSON.

RuleCurveClassifier class

Classifies curves with the environment's family and style rules (data-driven; no code per mnemonic).

Inherits / implements: ICurveClassifier

MemberSummary
RuleCurveClassifier(LogSettings settings)Classifies curves with the family and style rules of settings.
CurvePresentation Classify(string mnemonic)Family and style of a curve by mnemonic from the environment's family and style rules (first matching rule wins).
static bool Matches(MnemonicMatch m, string mnemonic, string family)True when a mnemonic (or its family) satisfies a match rule (exact, prefix, contains or family).

SchemaMigrations static class

Shared JSON schema-version handling for every library document.

MemberSummary
const string VersionProperty = "schemaVersion"Name of the schema version property in JSON documents.
static JsonObject Upgrade(string json, string documentKind, int current, IReadOnlyDictionary<int, Action<JsonObject>> steps)Reads schemaVersion (missing = 1), applies migrations up to current, and returns the upgraded object. Throws NotSupportedException for documents newer than this library.

SchematicSettings class

Environment section: schematic layout geometry.

MemberSummary
Dictionary<string, string> HostFamilies { get; set; }How each host slot is drawn: tubing, linerInCasing, liner or casing (add a slot here and in hostRadii).
Dictionary<string, float> HostRadii { get; set; }Radius of each equipment host slot (symbol units): where equipment of that slot sits between the strings.
float OverlayReach { get; set; }How far an overlay reaches outward from its slot (symbol units).
Dictionary<string, RoleDefinition> Roles { get; set; }Symbol roles: which items the logic treats as tubing, production casing, packer, safety valve, wellhead, tree, BOP, cement plug, plug foundation, control line, open hole... Add your own symbols or types to a role (maps merge by role).

SeparationLevel class

A separation-factor level: separation below Below triggers it (most severe = lowest).

MemberSummary
double Below { get; set; }Separation factor below which the level applies.
string Color { get; set; }Colour on the plots.
string Name { get; set; }Level name (report, shut-in / adjust plan, stop ...).

SeparationPoint class

Separation between the reference well at one depth and the closest point of an offset well (metres).

MemberSummary
double Adp { get; }Allowable deviation from plan, Distance - MASD (m).
double CylinderAngle { get; set; }Travelling cylinder: direction of the offset in the plane normal to the reference well, from north (deg).
double CylinderDistance { get; set; }Travelling cylinder: distance in that plane (m).
double Distance { get; set; }Centre-to-centre distance (m).
string Level { get; set; }Level reached (null: none).
double Masd { get; set; }Minimum allowable separation distance (m).
double OffsetMd { get; set; }Offset-well MD of the closest point (m).
double ReferenceMd { get; set; }Reference-well MD (m).
double SeparationFactor { get; set; }Separation factor.
double SigmaS { get; set; }Combined 1-sigma position uncertainty along the centre-to-centre direction (m).

SequentialIdGenerator class

Deterministic ids: prefix + a counter (thread-safe), for example id000001, id000002...

Inherits / implements: IIdGenerator

MemberSummary
SequentialIdGenerator(string prefix = "id", long start = 1)Ids prefix000001, 000002... from start.
string NewId()A new id.

SourceRef class

Where a record came from (PPDM keeps SOURCE in version keys; every canonical record keeps this).

MemberSummary
string Entity { get; set; }Table / object / file name.
string Key { get; set; }Key values joined with '|'.
DateTime? RetrievedUtc { get; set; }When the record was retrieved (UTC).
string System { get; set; }Source system, e.g. "PPDM 3.9", "Seabed", "WITSML 1.4.1", "CSV".
string Version { get; set; }Optional source/version discriminator (PPDM SOURCE, OBS_NO, WITSML uid…).

SpliceOptions class

Options of a splice.

MemberSummary
Dictionary<string, List<double>> CurveSpliceDepths { get; }Splice depths per curve (mnemonic -&gt; depths between consecutive runs, top down), overriding the rule for that curve.
string Name { get; set; }Name of the composite set.
SpliceRule Rule { get; set; }Overlap rule.

SpliceRule enum

Which run's data a splice keeps where runs overlap.

MemberSummary
PreferDeeperRunThe deeper run from its top down (the usual choice: the later, deeper run over the overlap).
PreferShallowerRunThe shallower run down to its bottom.

StandardLexicons static class

Published stratigraphic standards built into the library, layered under a company's own lexicons (resources.standardLexicons): ICS - the International Chronostratigraphic Chart v2020/01 (178 units: ranks, hierarchy, boundary ages, CGMW colours, names in 20 languages).

MemberSummary
static IReadOnlyCollection<string> Names { get; }Names of the built-in standards.
static JsonStratigraphicLexicon Get(string name)A built-in standard lexicon by name, or null.
static bool IsStandard(object lexicon)True when the lexicon is one of the built-in standards (saved configurations refer to it by name).

StationCovariance class

Position covariance at a station (north, east, vertical), in the survey's length unit squared.

MemberSummary
double EE { get; set; }East variance.
double EV { get; set; }East-vertical covariance.
double Md { get; set; }Measured depth.
double NE { get; set; }North-east covariance.
double NN { get; set; }North variance.
double NV { get; set; }North-vertical covariance.
double VV { get; set; }Vertical variance.

StationUncertainty class

Position uncertainty at a survey station: covariance (north, east, vertical) and ellipses.

MemberSummary
Dictionary<string, (double, double, double)> CorrelatedVectors { get; }Error-vector sums of the geomagnetic terms correlated between wells (code -&gt; north, east, vertical), for the cross-well correction.
double[] Covariance { get; }Covariance (unit squared), row/column order north, east, vertical (down).
double East { get; set; }Easting.
(double, double, double) HorizontalEllipse { get; }Horizontal ellipse at Sigma: semi-axes and azimuth of the major axis (degrees from north, 0-180).
double Md { get; set; }Measured depth (trajectory unit).
double North { get; set; }Northing (trajectory unit).
double Sigma { get; set; }Confidence multiplier used for the ellipses.
double SigmaEast { get; }Standard deviation east.
double SigmaNorth { get; }Standard deviation north.
double SigmaVertical { get; }Standard deviation vertical.
double Tvd { get; set; }True vertical depth.
static (double, double, double) Ellipse(double cxx, double cxy, double cyy, double k)Semi-axes (multiplied by k) and major-axis angle (degrees from x toward y) of a 2 x 2 covariance.
(double, double, double) SectionEllipse(double azimuth)Ellipse in the vertical section plane of azimuth (x = horizontal along the azimuth, y = vertical down): semi-axes and angle of the major axis from x toward y (degrees).

StratigraphicUnit class

A canonical stratigraphic unit (formation / layer) with its local names.

MemberSummary
List<string> Aliases { get; set; }Other spellings / company or country names that mean this unit.
double? BaseAgeMa { get; set; }Age of the base in million years (chronostratigraphic units).
string Color { get; set; }Display colour of the unit (#rrggbb).
string Id { get; set; }Canonical unit identifier (for example BURGAN); matching and correlation use it.
string Lithology { get; set; }Lithology code used to fill the unit where no lithology is given.
Dictionary<string, string> LocalNames { get; set; }Localized display names by culture (nb-NO, ar-KW…) or company key.
string Name { get; set; }Official unit name.
string Parent { get; set; }Id of the enclosing unit (in this or another lexicon layer) - a company formation can name a chart unit (e.g. Albian).
string Rank { get; set; }Rank (Eon, Era, Period, Epoch, Age ... for chronostratigraphy; Group, Formation, Member ... for lithostratigraphy).
double? TopAgeMa { get; set; }Age of the top in million years.

StratigraphyQueries static class

Hierarchy and ages of stratigraphic units across lexicon layers (a company formation's parent can be a chart unit).

MemberSummary
static (double?, double?) Ages(IStratigraphicLexicon lexicon, StratigraphicUnit unit)Base and top age (Ma): the unit's own, else those of its nearest dated enclosing unit.
static IEnumerable<StratigraphicUnit> Ancestors(IStratigraphicLexicon lexicon, StratigraphicUnit unit)The enclosing units of unit, nearest first (cycles and missing parents end the walk).
static StratigraphicUnit AtRank(IStratigraphicLexicon lexicon, StratigraphicUnit unit, string rank)The unit itself or its nearest enclosing unit of rank rank, or null.

StringKind enum

Kind of tubular string.

MemberSummary
ConductorConductor.
SurfaceSurface casing.
IntermediateIntermediate casing.
ProductionProduction casing.
LinerLiner.
TubingProduction / injection tubing.
DrillStringDrill string.
CoiledTubingCoiled tubing.
RodsSucker rods.
OpenHoleOpen hole (no pipe).

StyleSettings class

Environment section: domain colours (barriers, contacts, dips, fluids, statuses, palettes).

MemberSummary
string AnnotationColor { get; set; }Colour of new annotations.
Dictionary<string, string> AnnulusFluidColors { get; set; }Annulus fluid fill colours by fluid (Brine, Water, WaterBasedMud, OilBasedMud, Diesel, PackerFluid, Nitrogen, Gas, Cement, Unknown).
string BarrierEnvironmental { get; set; }Environmental (surface) barrier colour (P&amp;A convention: green).
string BarrierPrimary { get; set; }Primary well barrier colour (NORSOK D-010 convention: blue).
string BarrierSecondary { get; set; }Secondary well barrier colour (NORSOK D-010 convention: red).
Dictionary<string, string> BondColors { get; set; }Cement bond quality colours (Good, Partial, Poor).
string ChangeAdded { get; set; }State comparison: added item colour.
string ChangeModified { get; set; }State comparison: modified item colour.
string ChangeRemoved { get; set; }State comparison: removed item colour.
Dictionary<string, string> ContactColors { get; set; }Fluid contact colours by code (GOC, GWC, OWC, FWL, GDT, ODT, OUT, WUT).
List<string> CorrelationPalette { get; set; }Correlation-line colours for tops, cycled in top order (contacts keep their contact colour).
Dictionary<string, string> DipColors { get; set; }Dip pick colours by type (Bedding, CrossBedding, FractureOpen, FractureHealed, Fault, Unconformity, Unknown).
Dictionary<string, string> GasCharacterColors { get; set; }Mud-gas fluid character colours (VeryDryGas, Gas, GasWithOil, Oil, ResidualOil).
List<ColorStop> ImagePalette { get; set; }Borehole image palette: colour stops from 0 (low) to 1 (high); default 'heated'.
Dictionary<string, string> LeakPathColors { get; set; }Leak-path diagram colours (Source, Sink, Highlight).
Dictionary<string, string> PressureFluidColors { get; set; }Pressure gradient colours by fluid (Gas, Oil, Water, Unknown).
Dictionary<string, string> SectionColors { get; set; }Well-path / cross-section drawing colours (Steel, Cement, OpenHoleFill, OpenHoleEdge, Equipment, WellPath).
Dictionary<string, string> StatusColors { get; set; }Status colours: barrier elements (Intact, Unverified, Impaired, Failed, Open), requirement (Pass, Fail), annuli (Ok, AboveMawop, AboveMaasp, NoData), live feed (Live, Stale, Waiting), documents (Planned, AsBuilt), off-line wells (OffLine).
string TopMarkerColor { get; set; }Colour of a formation top whose stratigraphic unit has no colour.
Dictionary<string, string> TrajectoryColors { get; set; }Trajectory track colours (Inclination, Azimuth, Dogleg).
List<string> ZoneTints { get; set; }Cross-section zone tints for zones without a lithology, cycled.

SurveyErrorContext class

The field and reference values the sensor terms need for a well.

MemberSummary
string AzimuthReference { get; set; }North the station azimuths refer to: True or Grid.
double BTotal { get; set; }Total magnetic field strength (nT).
double Convergence { get; set; }Grid convergence (degrees).
double Declination { get; set; }Magnetic declination (degrees, east positive).
double Dip { get; set; }Magnetic dip (degrees).
double Gravity { get; set; }Gravity (m/s2).
double? Latitude { get; set; }Latitude of the well (degrees) - needed by gyro terms.
string Source { get; set; }Where the field values come from (header, or the geomagnetic model with place and date).

SurveyLeg class

A leg of the survey program in the view's survey unit.

MemberSummary
double FromMd { get; set; }Start depth in the survey unit.
string ToolModel { get; set; }Survey tool error model name.

SurveyProgramLeg class

One leg of a survey program: the tool (error model) that surveyed from a depth.

MemberSummary
Quantity FromMd { get; set; }Start depth of the leg (a station at this depth belongs to it).
string Name { get; set; }Survey name or run.
Quantity ToMd { get; set; }End depth, when known (informative: the next leg's start ends this one).
string ToolModel { get; set; }Survey tool error model name (a key of the environment's survey.toolModels).

SurveyPrograms static class

The survey program a well's data gives.

MemberSummary
static List<SurveyLeg> Effective(WellModel model, string unit)Explicit legs when the well has them; otherwise legs where the stations' tool changes; otherwise none (the default tool).

SurveySettings class

Environment section: survey quality control.

MemberSummary
Measure DoglegCourseLength { get; set; }Course length dogleg severity is expressed per (none: 100 ft for surveys in feet, 30 m in metres; Russia / CIS: 10 m).
double DoglegWarning { get; set; }Dogleg severity above which a survey station is flagged, in degrees per survey.doglegCourseLength (WV013).
bool GridConvergencePositiveEast { get; set; }Grid convergence sign: true = positive when grid north is east of true north (grid azimuth = true azimuth - convergence).
string ToolModel { get; set; }Survey tool error model used for position uncertainty (a key of ToolModels; default the OWSG standard MWD model MWD+SRGM, A001Mc).
Dictionary<string, ToolErrorModel> ToolModels { get; set; }Survey tool error models by name (built in: ISCWSA MWD Rev5 and 53 OWSG Tool Group A Rev 5.1 models); add your own.
UncertaintySettings Uncertainty { get; set; }Position uncertainty: error sources and ellipse settings.
string WorkingNorth { get; set; }North that trajectories, maps and sections work in (Grid or True); survey azimuths are corrected to it.

SurveyStation class

A directional survey station: measured depth, inclination, azimuth and optional TVD.

MemberSummary
double Azimuth { get; set; }Azimuth (degrees from grid north).
double Inclination { get; set; }Inclination (degrees).
Quantity Md { get; set; }Measured depth of the station.
string Tool { get; set; }Survey tool (error model name) that measured this station, when the data says so.
Quantity Tvd { get; set; }True vertical depth when the source gives it.

SurveyUncertainty static class

Survey position uncertainty in the ISCWSA structure: each error source has a size, a weighting function (its effect on MD, inclination or azimuth at a station) and a propagation mode; error derivatives use balanced-tangential station geometry; random errors add as independent covariances, systematic and global errors add as correlated vectors. The default sources are a simplified MWD subset (environment survey.uncertainty) - replace them with your tool model's values.

MemberSummary
static List<StationUncertainty> Compute(Trajectory trajectory, IReadOnlyList<ErrorSource> sources = null, double? sigma = null)Uncertainty at every station of trajectory (sources and sigma from the environment unless given).
static List<StationUncertainty> ForWell(Trajectory trajectory, SurveyErrorContext context, List<string> warnings = null)Uncertainty along a trajectory with the environment's survey tool model (survey.toolModel, ISCWSA formulation) when the well's magnetic reference is known; otherwise the simple error sources (said in warnings).
static List<StationUncertainty> ForWell(Trajectory trajectory, SurveyErrorContext context, IReadOnlyList<SurveyLeg> program, List<string> warnings = null)As String}) with a survey program: each leg's tool model from its start depth (tools missing from survey.toolModels fall back to survey.toolModel, said in warnings).

SymbolRoles static class

Symbol roles in effect (environment schematic.roles): does an item play a role in the logic?

MemberSummary
static bool Is(string role, string symbolId, string componentType = null)True when an item with symbolId and componentType plays role; an unknown role matches nothing.

SystemClock class

The system clock.

Inherits / implements: IClock

MemberSummary
static SystemClock Instance { get; }The shared instance.
DateTime UtcNow { get; }The current time (UTC).

TallyColumnSpec class

A column of the completion tally.

MemberSummary
string Header { get; set; }Header text (labels file key tally.col.&lt;key&gt; still applies).
string Key { get; set; }Column key: no, name, type, top, tvd, bottom, length, od, id, weight, grade, connection, manufacturer, part, serial, source, or any attribute key.

TextEncodings static class

Text file encodings for files from anywhere: a byte-order mark wins; otherwise strictly valid UTF-8 is read as UTF-8 (legacy text is practically never valid UTF-8 by accident); otherwise the legacy code page given, else the environment's files.legacyEncoding (windows-1251 / cp866 Cyrillic, gbk Chinese, shift_jis Japanese, windows-1256 Arabic...).

MemberSummary
static (string, Encoding, bool) Decode(byte[] bytes, string legacy = null)Decodes a whole file's bytes (see Int32@)); returns the text, the encoding used and whether it was the legacy code page.
static Encoding Detect(ReadOnlySpan<byte> sample, string legacy, bool usedLegacy, int bomLength)The encoding of text starting with sample: byte-order mark, else valid UTF-8, else the legacy code page (legacy, else files.legacyEncoding). usedLegacy is true when the legacy code page was chosen.
static StreamReader OpenText(string path, string encoding, Encoding used, bool usedLegacy)Opens a text file for streaming: encoding when given, else detected from the first megabyte (see Int32@)).
static Encoding Resolve(string name)The encoding for a name (throws ArgumentException when unknown).
static bool TryResolve(string name, Encoding encoding)The encoding for a name (web name, code page number or a common alias such as cp1251); false when unknown.

ThemeSettings class

Environment section: theme colours, fonts and line widths shared by all views.

MemberSummary
string Cursor { get; set; }Depth cursor colour.
float DepthFontSize { get; set; }Depth label font size (px).
string DepthLabel { get; set; }Depth label colour.
string DepthTrackBackground { get; set; }Depth track background colour.
string Frame { get; set; }Frame colour.
float FrameWidth { get; set; }Frame line width (px).
string Grid { get; set; }Grid line colour.
string HeaderBorder { get; set; }Header border colour.
string HeaderFill { get; set; }Header fill colour.
float LabelFontSize { get; set; }Label font size (px) of schematic equipment labels.
float MarkerWidth { get; set; }Top / marker line width (px).
string Preset { get; set; }Theme preset applied under the explicit keys: a name from theme.presets (light, dark, print, highContrast or your own).
Dictionary<string, Dictionary<string, string>> Presets { get; set; }Theme presets by name (colour keys filled under the explicit ones); add your own or change the built-in ones.
string SectionHeader { get; set; }Section header bars in tables (e.g. Annuli).
string Selection { get; set; }Selection highlight colour.
float SubtitleFontSize { get; set; }Track subtitle font size (px).
string Surface { get; set; }Canvas surface colour.
string SurfaceBorder { get; set; }Canvas surface border colour.
string Text { get; set; }Text colour.
float TitleFontSize { get; set; }Track title font size (px).
string TrackBackground { get; set; }Track background colour.

ToolboxRegistration class

A registered toolbox: its name in the environment's "toolboxes" section, its settings type and validator.

MemberSummary
Func<object, WellboreEnvironment, IEnumerable<string>> Check { get; }Checks the files and folders the settings point to (they may not exist, or may not load) - beyond what Validate can say about the values alone. Run by wellbore-config validate, not by Validate(), because it touches the disk.
string Description { get; }What the toolbox does (schema description).
string Name { get; }Section name (toolboxes.&lt;name&gt;).
Type SettingsType { get; }Settings type (deserialised from the section, defaults when absent).
Func<object, IEnumerable<string>> Validate { get; }Validator of the settings (problems as messages).

ToolboxRegistry static class

Toolboxes - libraries on top of the core (well integrity, drilling, production, data and AI, training) - register their settings here; the environment then carries them under "toolboxes", validates them and lists them in the template and schema.

MemberSummary
static IReadOnlyList<ToolboxRegistration> All { get; }The registered toolboxes, by name.
static List<string> CheckResources(WellboreEnvironment env)Problems with the files and folders the registered toolboxes' settings point to ("toolboxes.&lt;name&gt;: ...").
static JsonObject EffectiveSettings(WellboreEnvironment env)The effective settings of every registered toolbox as JSON: its defaults with the environment's own values laid over them (objects merge key by key, so a file that sets one value keeps the defaults of the others). A toolbox that is not registered keeps only what the files say.
static void Register<T>(string name, Func<T, IEnumerable<string>> validate = null, string description = null)Registers a toolbox (idempotent per name; the last registration of a name wins).
static void Register<T>(string name, Func<T, IEnumerable<string>> validate, string description, Func<T, WellboreEnvironment, IEnumerable<string>> check)Registers a toolbox (idempotent per name; the last registration of a name wins).
static bool Unregister(string name)Removes a toolbox registration (e.g. a host unloading a plug-in); false when it was not registered.

ToolErrorModel class

A survey tool error model: its terms and parameters (for example ISCWSA MWD Rev 5).

MemberSummary
string Application { get; set; }What the model applies to.
double HorizontalEastWestExclusion { get; set; }Exclusion around horizontal east / west (degrees; axial-correction models): stations inside it are reported.
double InclinationMax { get; set; }Highest inclination the model is valid for (degrees).
double InclinationMin { get; set; }Lowest inclination the model is valid for (degrees).
string LongName { get; set; }Long name.
double MisalignmentMinCourseLength { get; set; }Minimum course length of the misalignment terms XYM3E / XYM4E (m).
string Name { get; set; }Model name.
double NoiseReductionFactor { get; set; }Noise reduction factor of the gyro random noise term GXY-RN (1: none).
string Notes { get; set; }Notes (deviations from the published table and why).
Dictionary<string, double> Parameters { get; set; }Named parameters the term formulas use (for example GXYRunningSpeed).
string Prefix { get; set; }OWSG prefix (for example A001Mc).
string Source { get; set; }Where the model comes from.
double? StaticGyroEndInclination { get; set; }Inclination (degrees) where a gyro tool changes from stationary to continuous surveying and re-initialises on each new crossing ("XY Static Gyro End Inc"); negative: continuous from the first station; none: no switching.
List<ToolErrorTerm> Terms { get; set; }The error terms.
double Tortuosity { get; set; }Tortuosity of the long-course-length terms (rad/m); ISCWSA default 0.000572615.
double VerticalIncLimit { get; set; }Inclination below which a station is treated as vertical (degrees).
static ToolErrorModel FromIscwsaJson(string json)Reads a model in the ISCWSA error-model JSON format (https://github.com/iscwsa/error-models - metadata, parameters and terms with formulas; comments allowed). A term naming a built-in function (x_owsg_weight_function) uses it; otherwise its formulas.

ToolErrorResult class

Result of an ISCWSA error model computation: totals and each term, per station.

MemberSummary
Dictionary<string, List<(double, double, double)>> CorrelatedVectors { get; }For the geomagnetic terms correlated between wells (ISCWSA technical supplement "Application of Partial Correlations Between Geomagnetic Terms": DEC / DBH / MFI / MDI -CH, -CI, -OS, -OH, -OI): per station, the sum of the term's error vectors over all preceding stations plus the half-interval vector of the station (north, east, vertical, in the result's depth unit).
Dictionary<string, List<StationCovariance>> Terms { get; }Covariance of each term per station.
List<StationCovariance> Totals { get; }Total covariance per station.
List<string> Warnings { get; }Terms that could not be computed (unknown function, bad unit).

ToolErrorTerm class

One error term of a survey tool model (an OWSG / ISCWSA error code).

MemberSummary
string AzimuthFormula { get; set; }Azimuth weighting formula.
bool CarryAboveMax { get; set; }Above IncMax the weight stays at its value where the well crossed it (a stationary gyro's initialisation error carried into continuous surveying).
bool CarryOnly { get; set; }Zero below IncMin, above it the value at the crossing (an initialisation seed).
string Code { get; set; }Error code (DRFR, ABXY-TI1S, DEC-OS...).
string DepthFormula { get; set; }Depth weighting formula (ISCWSA / OWSG formula text), used when Function is not a built-in function.
string Description { get; set; }What the error is.
string EastSingularity { get; set; }East error at a vertical station (formula).
string Function { get; set; }Weighting function (DREF, DSF, DST, ABXY-TI1, ABXY-TI2, ABZ, ASXY-TI1..3, ASZ, MBXY-TI1..2, MBZ, MSXY-TI1..3, MSZ, AZ, DBH, AMIL, SAGE, XYM1, XYM2, XYM3L, XYM4L, XCLH, XCLA).
string InclinationFormula { get; set; }Inclination weighting formula.
double? IncMax { get; set; }Highest inclination the term applies at (degrees).
double? IncMin { get; set; }Lowest inclination the term applies at (degrees; gyro zones).
double Magnitude { get; set; }One-sigma magnitude, in Unit.
string NorthSingularity { get; set; }North error at a vertical station (formula), per unit magnitude and length.
string Propagation { get; set; }random, systematic (per survey leg), well (well by well) or global.
string Source { get; set; }Where the term comes from (paper, table).
string Unit { get; set; }m, -, 1/m, m/s2, nT, deg or deg.nT.
string VerticalSingularity { get; set; }Vertical error at a vertical station (formula).

Trajectory class

Well path by the minimum curvature method (industry standard): each survey interval is a circular arc; TVD, northing and easting use the ratio factor RF = 2/β·tan(β/2). Interpolation between stations follows the same arc (not linear). MD, TVD, N and E share Unit.

MemberSummary
Trajectory(string unit, IReadOnlyList<TrajectoryStation> stations)A trajectory in unit from computed stations.
IReadOnlyList<TrajectoryStation> Stations { get; }The computed stations, top down.
string Unit { get; }Length unit (canonical symbol, "ft" or "m").
(double, double, double, double, double) At(double md)Position and direction at any MD: on the arc between stations; straight tangent beyond the last one.
double Closure()Alias of ClosureAzimuth.
double ClosureAzimuth()Direction of the largest closure (azimuth from the wellhead to the deepest station), degrees.
static Trajectory Compute(IEnumerable<(double, double, double)> survey, string unit = null)Computes stations from (MD, inclination, azimuth). A vertical tie-on at MD 0 is added when missing.
static double DoglegCourse(string unit)Course length (in unit) that dogleg severity is expressed per: survey.doglegCourseLength, else 100 ft / 30 m.
static string DoglegCourseLabel(string unit)The course length label of dogleg severity ("100 ft", "30 m", "10 m").
static Trajectory FromSurvey(IEnumerable<SurveyStation> survey, string unit)From canonical survey stations (converted to unit).
double? MdAtTvd(double tvd)First MD reaching tvd (TVD is not monotonic in horizontal wells; the shallowest MD wins).
static (double, double, double, double) Step(double inc1, double azi1, double inc2, double azi2, double dmd)Minimum-curvature increments for one arc: (ΔTVD, ΔN, ΔE, dogleg β in radians).
double TvdAt(double md)True vertical depth at a measured depth (interpolated along the curvature).
double VerticalSection(double md, double azimuthDeg)Horizontal displacement projected on azimuthDeg (vertical-section direction).

TrajectoryStation class

A computed trajectory point (angles in degrees, lengths in the trajectory unit).

MemberSummary
double Azimuth { get; set; }Azimuth (degrees from grid north).
double Dls { get; set; }Dogleg severity of the segment ending here (degrees per 100 ft, or per 30 m for metric).
double East { get; set; }Easting offset from the surface location.
double Inclination { get; set; }Inclination (degrees).
double Md { get; set; }Measured depth.
double North { get; set; }Northing offset from the surface location.
double Tvd { get; set; }True vertical depth.

TubularCatalog static class

The tubular catalogue of the environment (tubulars: API 5CT / ISO 11960 by default; GOST 632-80 / 633-80 in Russia and the CIS...): standard casing and tubing sizes in the catalogue's unit, grades and connections - for validation and size choices.

MemberSummary
static string Standard { get; }The standard the catalogue follows.
static bool InRange(double outerDiameterInches, bool tubing)True when the diameter is within the catalogue's range (sizes outside it - conductors, line pipe - are not judged).
static bool IsConnection(string connection)True when the connection is one of the catalogue's (case, spaces and hyphens ignored).
static bool IsGrade(string grade)True when the grade is one of the catalogue's (case, spaces and hyphens ignored).
static bool IsStandard(double outerDiameterInches, bool tubing, double toleranceMm = 0.6)True when the diameter is a standard size, within toleranceMm (0.6 mm by default: catalogues in whole millimetres round API sizes, e.g. 245 mm for 9 5/8 in = 244.48 mm).
static double? Nearest(double outerDiameterInches, bool tubing)The nearest standard size in inches, or null when the catalogue has none.
static double? ParseSize(string text, string unit)A size as catalogues write it ("9 5/8", "1.050", "114") in unit, converted to inches; null when not a size.
static IReadOnlyList<double> SizesInches(bool tubing)The standard casing (or tubing) outside diameters in inches, smallest first.

TubularSettings class

Environment section: the tubular catalogue offered in editors (casing and tubing sizes, grades, connections of a standard).

MemberSummary
List<string> CasingSizes { get; set; }Casing outside diameters.
List<string> Connections { get; set; }Connection types.
List<string> Grades { get; set; }Steel grades / strength groups.
string Notes { get; set; }Notes (edition followed, other standards in use).
string SizeUnit { get; set; }Unit of the sizes (in or mm).
string Standard { get; set; }Standard the catalogue follows (information).
List<string> TubingSizes { get; set; }Tubing outside diameters.

TubularString class

A casing, liner, tubing or other tubular string: kind, depth range, cement and engineering attributes.

Inherits / implements: WellRecord

MemberSummary
EngineeringAttributes Attributes { get; set; }Engineering attributes (diameters, weight, grade...).
Quantity Bottom { get; set; }Bottom (shoe) of the string.
Quantity CementBottom { get; set; }Bottom of cement (default: the shoe).
Quantity CementTop { get; set; }Top of cement behind the string.
DateTime? InstallDate { get; set; }Installation date.
StringKind Kind { get; set; }Kind of string.
string Name { get; set; }String name, for example 9-5/8in production.
DateTime? RemovalDate { get; set; }Removal date.
ItemStatus Status { get; set; }Status.
Quantity Top { get; set; }Top of the string.
string WellboreId { get; set; }Wellbore the string is in.

UncertaintySettings class

Position uncertainty settings.

MemberSummary
int EllipseCount { get; set; }Most ellipses drawn along a path; they are drawn at survey stations (where the uncertainty is defined), evenly spread.
double Sigma { get; set; }Confidence multiplier of the ellipses (2 = two standard deviations).
List<ErrorSource> Sources { get; set; }Error sources. Default: a simplified MWD subset in the ISCWSA structure (typical magnitudes - use your tool model's values).

UnitDefinition class

A unit: its dimension, SI = value x Factor + Offset, and other spellings.

MemberSummary
List<string> Aliases { get; set; }Other spellings of the unit.
string Dimension { get; set; }Dimension: Length, LinearMass, Pressure, Temperature, Density, Angle...
double Factor { get; set; }Factor to SI (SI = value x Factor + Offset).
double Offset { get; set; }Offset to SI (temperatures).
static Dictionary<string, UnitDefinition> BuiltIn()The units the library starts with.

UnitEntry class

A unit as the unit catalog knows it: canonical symbol, dimension, SI = value x Factor + Offset.

MemberSummary
UnitEntry(string symbol, Dimension dimension, double factor, double offset = 0)Defines a unit: symbol, dimension and conversion to SI.
Dimension Dimension { get; }Dimension.
double Factor { get; }Factor to SI.
double Offset { get; }Offset to SI (temperatures).
string Symbol { get; }Canonical symbol.

Units static class

Unit conversions through the current services' unit catalog (IUnitCatalog, default: the environment's units.definitions). Unknown units are reported, never guessed.

MemberSummary
static string Canonical(string uom)Canonical symbol for an alias (e.g. "FEET" -&gt; "ft"); null when unknown.
static double Convert(double value, string from, string to)Converts between units of the same dimension (throws when unknown or incompatible).
static Dimension? DimensionOf(string uom)The dimension of a unit, or null when unknown.
static Dimension? DimensionOf(string uom, UnitSettings settings)The dimension of a unit in settings, or null when unknown.
static bool IsKnown(string uom)True when the unit (or an alias) is known.
static bool IsKnown(string uom, UnitSettings settings)True when uom is defined in settings (used to check an environment against its own units).
static bool TryConvert(double value, string from, string to, double result)Converts between units of the same dimension; false when unknown or incompatible.

UnitSettings class

Environment section: default depth unit and display units.

MemberSummary
Dictionary<string, string> Aliases { get; set; }Other spellings of known units (spelling -&gt; unit symbol, e.g. "FEET": "ft") - adds names without redefining the unit.
Dictionary<string, UnitDefinition> Definitions { get; set; }Unit definitions by symbol (dimension, factor to SI, offset, aliases); add or override units here.
string DepthUnit { get; set; }Default depth unit for new views and conversions: ft or m.
string DiameterUnit { get; set; }Diameter display unit in tables: in or mm.
string ForceUnit { get; set; }Force display unit (tension ratings and loads): klbf, lbf, kN, daN, tf.
string PressureUnit { get; set; }Pressure display unit (tables, readouts): psi, kPa, MPa, bar.
string System { get; set; }Unit system filling the unit settings not set explicitly (a key of Systems: oilfield, metric-kpa, metric-bar, metric-mpa or your own).
Dictionary<string, UnitSystem> Systems { get; set; }Unit systems by name: depth, pressure, diameter and weight units of each; add your own.
string WeightUnit { get; set; }Linear weight display unit in tables: lbm/ft or kg/m.

UnitSystem class

A unit system: the unit settings it fills.

MemberSummary
string DepthUnit { get; set; }Depth unit.
string DiameterUnit { get; set; }Diameter unit.
string ForceUnit { get; set; }Force unit (SI kN unless the system says otherwise).
string PressureUnit { get; set; }Pressure unit.
string WeightUnit { get; set; }Linear weight unit.

ValidationSettings class

Environment section: validation thresholds not covered by other sections.

MemberSummary
double CuttingsTotalTolerance { get; set; }Cuttings: allowed deviation of a sample's lithology total from 100 % (WL070).

VerificationSettings class

Environment section: reference cases run by wellbore-config verify (known answers; add your own, for example ISCWSA test wells).

MemberSummary
List<ReferenceCase> Cases { get; set; }Reference cases; the built-in ones have exact or closed-form answers (a list in an overlay replaces them).

VocabularyDomains static class

Vocabulary domains (what kind of code is being translated).

MemberSummary
static IReadOnlyList<string> ContactTypes { get; }Canonical fluid-contact codes (targets of the contactType domain).
static IReadOnlyList<string> AllEvery known domain name.
const string BarrierElementType = "barrierElementType"Well barrier element type codes (canonical: WbeTypes).
const string ComponentType = "componentType"Equipment / component type codes (canonical: ComponentTypes).
const string ContactType = "contactType"Fluid contact codes (canonical: ContactTypes).
const string CurveMnemonic = "curveMnemonic"Log curve mnemonics (company / vendor mnemonic to canonical mnemonic).
const string IntervalType = "intervalType"Contact interval types (perforation, open hole, screen...).
const string ItemStatus = "itemStatus"Item statuses (canonical: ItemStatus names).
const string Lithology = "lithology"Lithology codes (canonical: the lithology library codes).
const string StringKind = "stringKind"Tubular string kinds (canonical: StringKind names).

WbeTypeInfo class

A well barrier element type: code, name and its built-in acceptance-criteria reference.

MemberSummary
WbeTypeInfo(string code, string name, BarrierTargetKind kind, bool closes, string defaultRef)Creates element type information: code, name, what it targets, whether it closes the bore, default acceptance reference.
bool Closes { get; }Element seals the bore (valve, plug, BOP): drawn as a closure line across the well.
string Code { get; }Element type code.
string DefaultRef { get; }Verified acceptance-table reference (only where confirmed; revisions renumber tables).
BarrierTargetKind Kind { get; }Typical target kind.
string Name { get; }Display name.

WbeTypes static class

Well barrier element vocabulary (names as used in NORSOK D-010 WBE tables). Default acceptance references are only given where verified (Rev 3, 2004); later revisions renumber the tables — set AcceptanceRef.

MemberSummary
static IReadOnlyList<WbeTypeInfo> All { get; }Barrier element types of the model catalog in effect (default: the built-in model-catalog.json; configurable).
static string AcceptanceReference(string code)Acceptance-criteria reference for a WBE type: the environment's (company / revision) reference, else the built-in verified one.
static WbeTypeInfo Get(string code)The barrier element type of a code in the catalog in effect, or null.

WellBarrierSet class

A well barrier schematic's data for one well state: envelopes, WBEs and the WBS header block (NORSOK D-010: well information, planned / as-built status, revision, prepared / verified by, notes).

MemberSummary
DateTime? Date { get; set; }Date.
Quantity DesignPressure { get; set; }Design pressure.
List<BarrierEnvelope> Envelopes { get; set; }The envelopes.
string Field { get; set; }Field.
string Notes { get; set; }Notes.
string Phase { get; set; }Well activity / phase, e.g. "Production", "Drilling", "Permanent P&amp;A".
string PreparedBy { get; set; }Prepared by.
string Revision { get; set; }Revision.
BarrierDocumentStatus Status { get; set; }Planned or as built.
string VerifiedBy { get; set; }Verified by.
string WellType { get; set; }Well type the set was designed for.
IReadOnlyList<string> CommonTargets()Elements present in both the primary and the secondary envelope (common WBEs).
BarrierEnvelope Envelope(BarrierRole role)The envelope with a role, or null.

WellboreClock static class

The time from the current services' IClock (the system clock while the services are being created).

MemberSummary
static DateTime UtcNow { get; }The current time (UTC).

WellboreEnvironment class

Every customer-adjustable setting of the wellbore family (units, thresholds, standards references, classification rules, styles, print / live / conversion defaults, resource overrides), loadable from a JSON file per customer, country or tenant. A file only needs the keys it changes; everything else keeps the built-in default (which reproduces the library's original behaviour). Physical constants and algorithm internals are deliberately not configurable.

Inherits / implements: IJsonPersistable

MemberSummary
AbandonmentSettings Abandonment { get; set; }Permanent plug and abandonment checks.
AnnulusSettings Annuli { get; set; }Annuli / MAASP screening.
AntiCollisionSettings AntiCollision { get; set; }Anti-collision: ISCWSA separation rule parameters and levels.
BarrierSettings Barriers { get; set; }Well barriers.
string BaseDirectory { get; set; }Folder of the file this environment was loaded from (resolves relative resource paths); null when built in code.
BrandingSettings Branding { get; set; }Trademark footnote and logo on exports, prints and views.
CasingDesignSettings CasingDesign { get; set; }Casing design checks: rating method, grade yields, design factors, pipe dimensions.
CementSettings Cement { get; set; }Cement bond evaluation.
ConversionSettings Conversion { get; set; }Model-to-view conversion defaults.
CorrelationSettings Correlation { get; set; }Correlation panels.
CrossplotSettings Crossplots { get; set; }Crossplots (density-neutron, Pickett).
CrossSectionSettings CrossSection { get; set; }Cross-sections.
string Culture { get; set; }Culture for labels and localized layer names, e.g. en-US, nb-NO.
static WellboreEnvironment Current { get; }The environment in effect: the innermost WellboreServices scope, else Global.
Dictionary<string, DataSourceDefinition> DataSources { get; set; }The company's data sources by name (files, folders, exports, databases a host registers) with their profile overrides.
string Description { get; set; }Free text description.
DipSettings Dips { get; set; }Conventions of dip picks that do not state their own.
DisplaySettings Display { get; set; }Display defaults.
EquipmentSettings Equipment { get; set; }Equipment attribute rules and completion tally columns.
List<string> Extends { get; set; }Base environment file(s) this one extends (a company base, then country / asset overlays); later files win, objects merge key by key, lists are replaced. Paths are relative to this file.
FilesSettings Files { get; set; }Reading text files: legacy code page.
GasRatioSettings GasRatios { get; set; }Mud-gas ratio interpretation.
static WellboreEnvironment Global { get; set; }Process-wide environment (default: built-in defaults).
HistorySettings History { get; set; }Well history comparison.
ImageLogSettings ImageLogs { get; set; }Borehole image logs.
LiveSettings Live { get; set; }Real-time display.
LoaderSettings Loaders { get; set; }File loader settings.
LocaleSettings Locale { get; set; }How numbers and dates look on screen (files stay invariant).
LogSettings Logs { get; set; }Log curve families, styles and log validation thresholds.
MapSettings Map { get; set; }Well map (plan view).
string Name { get; set; }Name of this environment, e.g. customer or country profile.
OsduSettings Osdu { get; set; }OSDU export: data partition, ACL groups, legal tags, countries.
PetrophysicsSettings Petrophysics { get; set; }Computed petrophysical curves (shale volume, porosity, water saturation).
PressureSettings Pressure { get; set; }Formation pressure analysis.
PrintSettings Printing { get; set; }Printing and export.
IReadOnlyDictionary<string, string> Provenance { get; }Where each explicitly set value came from (path -&gt; file, or "preset:name"); unset values are defaults.
RegionSettings Region { get; set; }The country or region the environment is for.
ResourceSettings Resources { get; set; }External files overriding built-in resources (paths relative to this file).
SchematicSettings Schematic { get; set; }Schematic layout geometry (host slot radii).
int SchemaVersion { get; set; }Environment file schema version.
StyleSettings Styles { get; set; }Domain styles (barriers, contacts, dips, fluids, palettes).
SurveySettings Survey { get; set; }Survey quality control.
ThemeSettings Theme { get; set; }Theme colours and fonts.
static IReadOnlyDictionary<string, IReadOnlyDictionary<string, string>> ThemePresets { get; }Built-in theme presets (theme.preset): explicit theme keys still win over the preset.
Dictionary<string, JsonObject> Toolboxes { get; set; }Settings of toolboxes (well integrity, drilling, production, data and AI, training, or your own): one object per toolbox name.
TubularSettings Tubulars { get; set; }Tubular catalogue (casing and tubing sizes, grades, connections) of the standard in use.
UnitSettings Units { get; set; }Units.
ValidationSettings Validation { get; set; }Other validation thresholds.
VerificationSettings Verification { get; set; }Reference cases run by wellbore-config verify.
const int CurrentSchemaVersion = 1Environment file schema version written by this library.
static JsonSerializerOptions JsonOptionsJSON options used for environment files and the models (camelCase, comments and trailing commas allowed, enums as strings).
static double ContrastRatio(string a, string b)WCAG contrast ratio of two #rrggbb colours (1 to 21).
static WellboreEnvironment FromJson(string json)Parses an environment (warnings discarded).
static WellboreEnvironment FromJson(string json, List<string> warnings, string baseDirectory = null, string sourceName = "(json)")Parses an environment; keys not present keep their defaults. warnings lists unknown keys (with their path, e.g. cement.goodBondIndx), unresolvable base files and cycles. extends paths resolve against baseDirectory (the current directory when null).
static string JsonSchema()JSON Schema (draft-07) with descriptions and defaults — editors use it for completion and validation.
static WellboreEnvironment Load(string path, List<string> warnings)Loads an environment file (and the files it extends); relative resource paths resolve against each file's folder.
string SourceOf(string path)The source of a setting (e.g. "cement.goodBondIndex"): the file that set it, "preset:dark", or "default".
static string Template()The environment template: the defaults of every section, with every registered toolbox's defaults under "toolboxes".
string ToJson()The full environment as JSON (every key with its current value) — a template customers can edit.
T Toolbox<T>(string name)A toolbox's typed settings (defaults when its section is absent). Cached per environment, but only while the section object is the same one: replacing Toolboxes[name] (an editor changing a setting) makes the next call read it again, and the same section can be read as another type.
List<string> Validate()Range and consistency checks; an empty list means the environment is usable.

WellboreIds static class

New ids from the current services' IIdGenerator (random GUIDs while the services are being created).

MemberSummary
static string New()A new id.

WellboreInfo class

A drilled path (PPDM "Wellbore").

Inherits / implements: WellRecord

MemberSummary
Quantity KickoffDepth { get; set; }Kick-off depth from the parent.
string Name { get; set; }Wellbore name.
string ParentId { get; set; }Parent wellbore id (sidetracks).
Quantity TotalDepth { get; set; }Total depth of the wellbore.

WellboreServices class

The configuration in effect: environment plus the contracts (vocabulary, lexicon, symbols, curve classifier, labels). Ambient (Current, scoped per request / tenant / test with WellboreServices)) or passed explicitly by DI hosts.

MemberSummary
WellboreServices(WellboreEnvironment environment = null)Services for an environment (default environment when null) with empty contracts; use WellboreEnvironment) to load the environment's resource files.
IClock Clock { get; set; }The current time (default: the system clock); set a FixedClock for deterministic runs.
ICountryCatalog Countries { get; set; }Ready-made country environments for "country:XX" (default: the 62 built-in countries); replace to offer the host's own.
static WellboreServices Current { get; }The innermost scope on this async flow, else Global.
ICurveClassifier Curves { get; set; }Curve classifier (mnemonics to families and styles).
WellboreEnvironment Environment { get; }The environment these services were built from.
WorldMagneticModel Geomagnetic { get; set; }Geomagnetic model for wells' magnetic field (default: the embedded WMM2025; resources.geomagneticModelFile loads another NOAA-format model).
static WellboreServices Global { get; set; }Process-wide services (setting this also sets Global).
IIdGenerator Ids { get; set; }New record ids (default: random GUIDs); set a SequentialIdGenerator for deterministic runs.
List<ConfigIssue> Issues { get; }Coded problems found in the resource files (lexicons, vocabularies, labels), also listed in Warnings.
ILabelProvider Labels { get; set; }Label provider (user-interface texts).
ILeakPathTemplates LeakPaths { get; set; }Leak-path networks and their selection (default: the built-in networks merged with resources.leakPathFiles); replace to use the host's.
IStratigraphicLexicon Lexicon { get; set; }Stratigraphic lexicon (formation-top names to units).
IModelCatalog ModelCatalog { get; set; }Component, barrier element and fluid contact types (default: the built-in catalog merged with resources.modelCatalogFiles); replace to take them from the host.
List<(string, string, string)> ResourceTexts { get; }Resource files read for other libraries by kind (for example "barrierTemplates"): file path and text, in the environment's order.
ISymbolResolver Symbols { get; set; }Symbol resolver (component types to schematic symbols).
IUnitCatalog UnitCatalog { get; set; }Units (default: the environment's units.definitions); replace to take units from the host.
ICodeVocabulary Vocabulary { get; set; }Code vocabulary (source codes to canonical values).
List<string> Warnings { get; }Problems met while building from resources (missing / invalid files): reported, never thrown.
static WellboreServices FromEnvironment(WellboreEnvironment environment)Services for an environment: vocabularies, lexicons, symbols and labels loaded from its resource files (paths relative to its file); missing or invalid files become Warnings and the null-object default stays in place.
T Get<T>()A contract registered by another library (for example the schematic library's barrier templates), or null.
static WellboreServices Load(string environmentFile)Loads an environment file and builds its services.
ConfigurationSaveReport SaveConfiguration(string folder)Saves the whole configuration to folder: environment.json plus every part as JSON (vocabulary, lexicon and label layers, component symbols, model catalog, leak-path networks, barrier templates, company countries, units, copied lithology / symbol catalog files), referenced from environment.json by relative paths. String) on folder/environment.json rebuilds the same services. Parts a host implemented without JSON are listed in the report, not saved.
static IDisposable Scope(WellboreServices services)Makes services current for this async flow until disposed (per request, tenant or test).
static IDisposable Scope(WellboreEnvironment environment)Makes services current for this async flow until disposed (per request, tenant or test).
void Set<T>(T implementation)Registers a contract implementation another library looks up with Get``1 (null removes it).

WellChange class

One difference between two states. Ids refer to state A (removed / modified) and state B (added / modified).

MemberSummary
string Author { get; set; }Who made the change (from the later model's audit trail), when known.
string Category { get; set; }String, Component, Interval, Barrier, Annulus.
List<FieldChange> Fields { get; set; }Changed fields.
string IdA { get; set; }Item id in the first state.
string IdB { get; set; }Item id in the second state.
ChangeKind Kind { get; set; }Added, removed or modified.
string Label { get; set; }Item label.
string Summary { get; }One-line description of the change.
DateTime? Utc { get; set; }When the change was made (UTC, from the audit trail), when known.

WellComponent class

An item in a string or the wellbore: packer, nipple, valve, plug, pump…

Inherits / implements: WellRecord

MemberSummary
EngineeringAttributes Attributes { get; set; }Engineering attributes.
Quantity Bottom { get; set; }Bottom of the component (null = top plus length when known).
DateTime? InstallDate { get; set; }Installation date.
string Name { get; set; }Component name.
DateTime? RemovalDate { get; set; }Removal date.
ItemStatus Status { get; set; }Status.
string StringId { get; set; }Owning string (null = set in the wellbore, e.g. a bridge plug).
Quantity Top { get; set; }Top of the component.
string Type { get; set; }Canonical component type (see ComponentTypes), e.g. PACKER_PERMANENT.
string WellboreId { get; set; }Wellbore the component is in.

WellDepthReference class

Depth reference system of a well: depth datum (KB, RT, DF, GL…) with its elevation above MSL, and the trajectory. MD and TVD are measured from the datum; TVDSS = TVD − datum elevation (positive below sea level).

MemberSummary
string DatumCode { get; set; }Depth datum code (KB, RT, DF, GL...).
Quantity DatumElevation { get; set; }Datum elevation above mean sea level.
SurveyErrorContext ErrorContext { get; set; }Magnetic field and references for the survey error model (null: unknown - the simple model is used).
Quantity GroundElevation { get; set; }Ground (or sea-bed) elevation.
List<(double, double, double)> Survey { get; set; }Raw survey (MD, inclination, azimuth) in SurveyUnit; the trajectory is computed from it.
List<SurveyLeg> SurveyProgram { get; set; }Survey program in the survey unit (empty: the environment's tool model for the whole survey).
string SurveyUnit { get; set; }Length unit of the raw survey.
Trajectory Trajectory { get; }Minimum-curvature trajectory (recomputed when the survey changes); null without survey.
double? Convert(double value, string unit, DepthPath from, DepthPath to)Converts a depth between references; unit is the unit of value and of the result.

WellHeader class

Well identification and location: name, UWI, operator, field, coordinates and depth datums.

Inherits / implements: WellRecord

MemberSummary
string Country { get; set; }Country.
string Crs { get; set; }Coordinate reference system of the location.
List<DatumElevation> Datums { get; set; }Datum elevations (KB, RT, DF, GL...).
string DepthDatum { get; set; }Datum all MD values refer to (e.g. KB).
string Field { get; set; }Field.
double? Gravity { get; set; }Gravity used for the survey (m/s2); none: WGS84 normal gravity at the latitude.
double? GridConvergence { get; set; }Grid convergence at the well (degrees; sign convention: environment survey.gridConvergencePositiveEast).
double? Latitude { get; set; }Surface latitude (degrees).
double? Longitude { get; set; }Surface longitude (degrees).
double? MagneticDeclination { get; set; }Magnetic declination used for the survey (degrees, east positive): true = magnetic + declination.
double? MagneticDip { get; set; }Magnetic dip used for the survey (degrees); none: from the geomagnetic model.
double? MagneticTotalField { get; set; }Total magnetic field used for the survey (nT); none: from the geomagnetic model at the well's location.
string Name { get; set; }Well name.
string Operator { get; set; }Operator.
DateTime? SurveyDate { get; set; }Date of the survey (the magnetic field is taken for it; none: today).
NorthReference? SurveyNorth { get; set; }North the survey azimuths refer to; null = grid (assumed, as earlier versions did).
Quantity TotalDepth { get; set; }Total depth.
string Uwi { get; set; }UWI / API / national identifier.

WellHistory class

Well life-cycle: planned, as-built, workovers… as dated snapshots (source-agnostic, versioned JSON).

Inherits / implements: IJsonPersistable

MemberSummary
WellState Current { get; }Latest as-built / workover state, else the latest state.
int SchemaVersion { get; set; }Schema version of this history.
List<WellState> States { get; set; }The states, oldest first.
string WellName { get; set; }Well name.
const int CurrentSchemaVersion = 1History file schema version written by this library.
IEnumerable<WellState> Chronological()States in time order (undated states first, in list order).
static WellHistory FromJson(string json)Reads a history (older schema versions are upgraded).
WellState Get(string idOrName)The state with an id or name, or null.
string ToJson()Serializes the history.

WellIdentifierFormat class

A national well identifier format: a regular expression over header fields, with an example for messages.

MemberSummary
string Example { get; set; }A valid example.
List<string> Fields { get; set; }Header fields checked: uwi and / or name.
string Name { get; set; }Name shown in messages (for example US API well number).
string Pattern { get; set; }Regular expression the whole value must match (case-sensitive).

WellIdentifiers static class

Checks well identifiers against the formats of the environment's country (region.wellIdentifiers).

MemberSummary
static List<ModelIssue> Check(WellHeader header)WI001 when the header has identifier values but none matches any configured format (the message lists the formats with examples); WI002 when a configured pattern is not a valid regular expression. No formats configured: nothing checked.

WellModel class

The library's canonical well: everything the well views need, independent of any source.

Inherits / implements: IJsonPersistable

MemberSummary
List<AnnulusInfo> Annuli { get; set; }Surface-accessible annuli with fluids, pressures and limits.
List<AuditEntry> Audit { get; set; }Audit trail: who changed what and when (appended, never rewritten).
List<WellBarrierSet> Barriers { get; set; }Well barrier sets (one per documented well state / phase).
List<WellComponent> Components { get; set; }Completion and other components.
List<ContactInterval> ContactIntervals { get; set; }Perforations and other contact intervals.
List<CoreSample> CoreSamples { get; set; }Core samples.
List<CoreShift> CoreShifts { get; set; }Core depth shifts.
List<CurveDepthShift> CurveShifts { get; set; }Recorded depth corrections of log curves (audit trail of depth matching).
List<CuttingsSample> CuttingsSamples { get; set; }Cuttings samples (mud log).
List<DipMeasurement> Dips { get; set; }Dip measurements.
List<GasReading> GasReadings { get; set; }Gas readings (mud log).
WellHeader Header { get; set; }Well header (name, location, datums).
List<HoleSection> HoleSections { get; set; }Hole sections (bit sizes).
List<LogSet> LogSets { get; set; }Log data (from any loader), format-neutral.
List<PressureTest> PressureTests { get; set; }Wireline formation pressure tests.
int SchemaVersion { get; set; }Schema version of this model.
List<TubularString> Strings { get; set; }Casing, liner and tubing strings.
List<SurveyStation> Survey { get; set; }Survey stations.
List<SurveyProgramLeg> SurveyProgram { get; set; }Survey program: which tool measured which depth interval (none: from the stations' tools, else the environment's tool model).
List<FormationTop> Tops { get; set; }Formation tops and fluid contacts.
List<WellboreInfo> Wellbores { get; set; }Wellbores (main bore first).
const int CurrentSchemaVersion = 1Model schema version written by this library.
static IReadOnlyDictionary<int, Action<JsonObject>> WellModelMigrationsMigration steps: key = from-version, action upgrades the JSON to from+1.
static WellModel FromJson(string json)Loads and migrates; rejects documents from a newer library version.
double MaxDepth(string uom)Deepest depth mentioned anywhere, in uom.
string ToJson()Serializes the model.

WellRecord abstract class

Common base: identity, provenance, preserved unmapped source fields.

MemberSummary
Dictionary<string, string> Extra { get; set; }Unmapped source columns/properties, kept verbatim (no silent data loss).
string Id { get; set; }Record id (unique within the well).
List<SourceRef> Sources { get; set; }Where the record came from (system, table, key, version).

WellState class

One documented state of a well (a full canonical snapshot).

MemberSummary
DateTime? Date { get; set; }Date of the state.
string Description { get; set; }Description.
string Id { get; set; }State id.
WellStateKind Kind { get; set; }Kind of state.
WellModel Model { get; set; }The well at this state.
string Name { get; set; }State name.
string Title { get; }Name with the date.

WellStateDiff static class

Compares two well states. Items match by id, then (for records from different systems or plans) by same type at the nearest depth within matchTolerance; matched items report field-level changes, unmatched ones are added / removed.

MemberSummary
static List<WellChange> Compare(WellModel a, WellModel b, string unit = null, double? matchTolerance = null, bool installedOnly = true)Differences from state a to state b, depths in unit; items of the same type within matchTolerance are paired; installedOnly ignores Removed / Abandoned items (as-is comparison, the same rule as the views).

WellStateKind enum

Kind of well state kept in a well history (for example planned or as built).

MemberSummary
PlannedPlanned design.
AsBuiltAs built.
WorkoverAfter a workover.
ProposedProposed change.
AbandonedAbandoned.

WorldMagneticModel class

Spherical-harmonic geomagnetic model read from a NOAA .COF coefficient file (World Magnetic Model; the WMM2025 file is embedded). Any model in the same format can be configured (resources.geomagneticModelFile).

MemberSummary
double Epoch { get; }Model epoch (decimal year).
double LifeSpan { get; set; }Life span in years after the epoch (5 for WMM).
string Name { get; }Model name from the file.
static WorldMagneticModel Wmm2025 { get; }The embedded World Magnetic Model 2025 (NOAA / BGS, public domain; valid 2025.0 - 2030.0).
MagneticFieldValues Calculate(double latitude, double longitude, double heightKm, double decimalYear)The field at geodetic latitude / longitude (degrees), height above the WGS84 ellipsoid (km) and time (decimal year).
static double DecimalYear(DateTime date)A date as a decimal year.
static WorldMagneticModel FromCof(string text)Reads a NOAA .COF coefficient file (header: epoch, model name, date; rows: n m g h dg dh; ends with 9999...).