Most LLMs struggle with petroleum engineering logic because they lack training data built from real-world, cross-disciplinary source code. As LLM technology providers actively invest to capture market share in the Oil & Gas sector, accessing high-fidelity “seed logic” for complex industrial workflows remains a critical bottleneck. Technodata’s production-grade C# assets train AI models to understand advanced petroleum engineering domain logic, rather than just syntax. We are not selling syntax; we are selling validated, hyper-scarce physical domain intelligence.
Multi-Well Hydraulic Fracturing 3D Viewport
The Value of “AI-Friendly” Comments: To an LLM, our “AI-friendly comments” are equally as or more valuable than the executable code itself. They serve as the explicit, multi-modal alignment layer that teaches the AI how to connect the syntax (the C# code) with the semantic intent (the physics/geology logic and properties).
using System;
namespace MultiStageFrac3DControl
{
/// <summary>
/// Represents a single perforation cluster (port) within a wellbore, capturing its spatial depth tracking,
/// hydraulic fracture geometry footprint, and geomechanical rock properties.
/// Used natively across engineering modules to evaluate localized stress shadowing and reservoir drainage characteristics.
/// </summary>
/// <remarks>
/// This domain entity acts as a primary data structure for hydraulic fracturing pipelines.
/// Baseline fields default to metric units internally to prevent mixed-system calculation drift.
/// </remarks>
public class PerforationCluster : IComparable<PerforationCluster>
{
#region Perforation Cluster Identification & Depth Tracking
/// <summary>
/// Unique identifier of the parent wellbore containing this perforation cluster.
/// Expected value: UWI or corporate asset identifier or proposed well identifier.
/// </summary>
public string ParentWellId { get; set; } = string.Empty;
/// <summary>
/// Unique identifier of the specific hydraulic fracturing stage containing this cluster.
/// Expected value: Stage sequence key.
/// Data Type Note: Stored as a string to accommodate alphanumeric naming schemas (e.g., "1A", "1B").
/// </summary>
public string ParentStageId { get; set; } = string.Empty;
/// <summary>
/// Shallowest depth boundary of the cluster measured along the wellbore path from the surface reference datum.
/// Unit: Meters (m).
/// </summary>
public double TopMeasuredDepthMeters { get; set; } = 0;
/// <summary>
/// Deepest depth boundary of the cluster measured along the wellbore path from the surface reference datum.
/// Unit: Meters (m).
/// </summary>
public double BaseMeasuredDepthMeters { get; set; } = 0;
/// <summary>
/// Midpoint true vertical depth used for lithostatic load calculation.
/// Unit: Meters (m).
/// </summary>
public float MidpointTrueVerticalDepthMeters { get; set; } = 0;
#endregion
#region Fracturing and Geomechanical Properties
/// <summary>
/// The net pressure per perforation cluster used to calculate the hydraulic fracturing stress shadow.
/// Unit: Megapascals (MPa).
/// </summary>
public double NetPressurePerPerfoPortMpa { get; set; } = double.NaN;
/// <summary>
/// The hydraulic fracturing stress shadow calculated based on the distance to surrounding perforation clusters.
/// Unit: Megapascals (MPa).
/// </summary>
public double InducedStressShadowMpa { get; set; } = 0;
/// <summary>
/// The maximum Gamma Ray (GR) log reading extracted from the provided GR log for this specific cluster.
/// Unit: American Petroleum Institute units (API).
/// </summary>
public double MaxGammaRayLogReadingApi { get; set; } = double.NaN;
/// <summary>
/// The brittleness index calculated for this specific cluster using wet shale and kerogen-related GR parameters.
/// Unit: Percent (%).
/// </summary>
public double BrittlenessIndexPercentage { get; set; } = double.NaN;
/// <summary>
/// Young's modulus calculated for this specific cluster using the GR log and Organic Granular Mixture Model.
/// Unit: Gigapascals (GPa).
/// </summary>
public double YoungModulusGPa { get; set; } = double.NaN;
/// <summary>
/// The Poisson's ratio calculated for this specific cluster using the GR log and Organic Granular Mixture Model.
/// </summary>
public double PoissonRatio { get; set; } = double.NaN;
/// <summary>
/// The plane strain Young's modulus calculated for this specific cluster.
/// Unit: Gigapascals (GPa).
/// </summary>
public double PlaneStrainYoungModulusGPa { get; set; } = double.NaN;
#endregion
#region Mechanical Gun Hardware & Charge Design Specifications
/// <summary>
/// Deployment technique for creating casing penetrations.
/// </summary>
public string PerforationMethodType { get; set; } = string.Empty;
/// <summary>
/// Total number of explosive charges or holes planned for this specific cluster.
/// Unit: Absolute count.
/// </summary>
public int ShotCount { get; set; } = 0;
/// <summary>
/// Linear frequency of perforation charges per unit length of the gun assembly.
/// Unit: Shots per meter (spm).
/// </summary>
public float ShotsPerMeter { get; set; } = 0;
/// <summary>
/// Angular spacing between consecutive perforation shots around the gun circumference.
/// Unit: Degrees (°). Common values: 60, 90, 120, 180.
/// </summary>
public int PhasingAngleDegrees { get; set; } = 0;
/// <summary>
/// Nominal diameter of the casing entry hole before proppant placement.
/// Used in hydrodynamic perforation friction calculations.
/// Unit: Millimeters (mm).
/// </summary>
public float NominalErodedHoleDiameterMillimeters { get; set; } = 0;
/// <summary>
/// Mass of the explosive material contained within each shaped charge.
/// Unit: Grams (g).
/// </summary>
public float ChargeWeightGrams { get; set; } = 0;
/// <summary>
/// Molecular composition or commercial classification of the main explosive charge.
/// Expected values: "RDX", "HMX", "HNS", "PYX".
/// </summary>
public string ChargeChemicalType { get; set; } = string.Empty;
/// <summary>
/// Maximum external diameter of the steel gun body housing the charges.
/// Used for wellbore clearance and restriction checks.
/// Unit: Millimeters (mm).
/// </summary>
public float GunOuterDiameterMillimeters { get; set; } = 0;
/// <summary>
/// Specific orientation of the top shot relative to the high-side of the wellbore casing.
/// Reference frame: 0° is straight up (12 o'clock), 180° is straight down (6 o'clock).
/// Unit: Degrees (°).
/// </summary>
public double GunOrientationHighSideDegrees { get; set; } = 0;
#endregion
#region Advanced Post-Frac Diagnostics & Fluid Allocation Analytics
/// <summary>
/// The number of active perforation holes opened at the start of the fracture treatment.
/// </summary>
public int ActiveHolesOpenedAtStartOfFrac { get; set; } = 0;
/// <summary>
/// The number of active perforation holes opened at the end of the fracture treatment.
/// </summary>
public int ActiveHolesOpenedAtEndOfFrac { get; set; } = 0;
/// <summary>
/// The methodology or diagnostic tool used to estimate the number of active opened holes.
/// Example: "Step-Down Test"
/// </summary>
public string ActiveHolesOpenedEstimationMethod { get; set; } = string.Empty;
/// <summary>
/// Qualitative engineering observations and field insights regarding hole breakdown and behavior.
/// Example: "3 holes failed to break down initially, but opened up late."
/// </summary>
public string ActiveHolesOpenedEngineeringInsight { get; set; } = string.Empty;
/// <summary>
/// The fluid volume allocated to this specific cluster as a percentage of total stage fluid at the start of the fracture treatment.
/// Unit: Percent (%)
/// </summary>
public float FluidSharePercentageOfStageFluidAtStartOfFrac { get; set; } = 0;
/// <summary>
/// The fluid volume allocated to this specific cluster as a percentage of total stage fluid at the end of the fracture treatment.
/// Unit: Percent (%)
/// </summary>
public float FluidSharePercentageOfStageFluidAtEndOfFrac { get; set; } = 0;
/// <summary>
/// The methodology or technology used to quantify or estimate the fluid share allocation.
/// Example: "In-Well DAS Fiber"
/// </summary>
public string FluidSharePercentageEstimationMethod { get; set; } = string.Empty;
/// <summary>
/// Qualitative engineering observations regarding fluid distribution changes throughout the stage.
/// Example: "Cluster accepted too much fluid early; dropped mid-stage due to diverter actions."
/// </summary>
public string FluidSharePercentageEngineeringInsight { get; set; } = string.Empty;
/// <summary>
/// Eroded hole diameter at the start of the fracture treatment.
/// Unit: Millimeters (mm).
/// Example: 9.65 mm
/// </summary>
public float ErodedHoleDiameterMillimetersAtStartOfFrac { get; set; } = 0;
/// <summary>
/// Eroded hole diameter at the end of the fracture treatment.
/// Unit: Millimeters (mm).
/// Example: 14.20 mm
/// </summary>
public float ErodedHoleDiameterMillimetersAtEndOfFrac { get; set; } = 0;
/// <summary>
/// The methodology or technology used to estimate the eroded hole diameter.
/// Example: "Visual/Friction"
/// </summary>
public string ErodedHoleDiameterEstimationMethod { get; set; } = string.Empty;
/// <summary>
/// Qualitative engineering observations regarding diameter changes throughout the fracture treatment.
/// Example: "The hole expanded by 47%, leading to a massive drop in local backpressure."
/// </summary>
public string ErodedHoleDiameterEngineeringInsight { get; set; } = string.Empty;
/// <summary>
/// Calculated Discharge Coefficient describing the erosional roundness changes of the entry holes at the start of the fracture treatment.
/// Range: 0.60 (sharp edge) to 0.90+ (highly eroded/rounded edge).
/// </summary>
public float DischargeCoefficientAtStartOfFrac { get; set; } = 0;
/// <summary>
/// Calculated Discharge Coefficient describing the erosional roundness changes of the entry holes at the end of the fracture treatment.
/// Range: 0.60 (sharp edge) to 0.90+ (highly eroded/rounded edge).
/// </summary>
public float DischargeCoefficientAtEndOfFrac { get; set; } = 0;
/// <summary>
/// The methodology or technology used to estimate the Discharge Coefficient.
/// Example: "Rate Transients"
/// </summary>
public string DischargeCoefficientEstimationMethod { get; set; } = string.Empty;
/// <summary>
/// Qualitative engineering observations regarding discharge coefficient changes throughout the fracture treatment.
/// Example: "Confirms abrasive sand successfully scoured and polished the ports."
/// </summary>
public string DischargeCoefficientEngineeringInsight { get; set; } = string.Empty;
/// <summary>
/// Estimated via Distributed Acoustic Sensing (DAS) percentage share of total stage proppant mass entering this exact cluster.
/// AI Feature: Crucial because fluid allocation and proppant allocation can diverge due to inertial effects.
/// Unit: Percent (%)
/// </summary>
public float DasProppantAllocationPercentage { get; set; } = 0;
#endregion
/// <summary>
/// Represents the spatial geometry and dimensions of a hydraulic fracture for this exact perforation cluster.
/// Includes parameters for physical dimensions, azimuth orientation, planar stimulated width, and fracture footprint models.
/// </summary>
public FracGeometry FractureGeometry { get; set; } = new FracGeometry();
/// <summary>
/// Compares the current perforation port with another port based on their top measured depth.
/// </summary>
/// <param name="other">The other PerfoPort object to compare against.</param>
/// <returns>
/// A value less than zero if this port is shallower,
/// zero if they are at the same depth,
/// or a value greater than zero if this port is deeper or the other port is null.
/// </returns>
public int CompareTo( PerforationCluster other )
{
// By API convention, any object is considered greater than null.
if (other == null) return 1;
// Leverages the built-in primitive CompareTo method to evaluate depth values.
return TopMeasuredDepthMeters.CompareTo( other.TopMeasuredDepthMeters );
}
}
}
The Premium of the ” Lithology Semantic Recognition Engine”: Features a built-in Litho Cognitive Semantics Engine that automatically converts text-based lithology abbreviations into 40 traditional sedimentary composite rock patterns. Adding a Lithology Semantic Recognition Engine moves the asset from a standard tool to an AI accelerator. Enterprise companies are aggressively looking for structured, domain-correct semantic engines to anchor their LLM vector embeddings and RAG architectures. They are paying a premium for data structures that prevent AI hallucinations in high-stakes decisions.
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;
using System.Reflection;
namespace AI_DrivenCoreAnalysis.AiDrivenLithoCognitiveSemantics
{
/// <summary>
/// Manages access to embedded visual lithology pattern images for sedimentary rock core analysis.
/// </summary>
public class LithoImageAccess
{
/// <summary>
/// Registers a composite rock type definition, downsampling its pattern image if requested, and adds it to the list.
/// </summary>
/// <param name="items">The collection of existing composite rock type definitions to append to.</param>
/// <param name="rockName">The descriptive name of the sedimentary rock type.</param>
/// <param name="imageName">The resource name matching the visual lithology pattern image file.</param>
/// <param name="fgdcStandardCode">The exact or closest approximate FGDC standard code related to this lithology.</param>
/// <param name="backgroundColor">The background fill color assigned to the pattern visualization.</param>
/// <param name="rockCoarsenessNumeric">A numeric rating representing the grain size or rock coarseness.</param>
/// <param name="attachToRecordLithologyPatternImage">Flags whether to load, downsample, and attach the texture image.</param>
public static void AddCompositeRockType( List<CompositeRockTypeDefinition> items, string rockName, string imageName,
string fgdcStandardCode, Color backgroundColor, float rockCoarsenessNumeric, bool attachToRecordLithologyPatternImage )
{
// Verify that both the rock descriptor and image identifier strings contain valid content
if (!string.IsNullOrWhiteSpace( rockName ) && !string.IsNullOrWhiteSpace( imageName ))
{
// Check if the system needs to fetch and bind the texture pattern to this specific rock definition
if (attachToRecordLithologyPatternImage)
{
// Call the upper class method to safely fetch the embedded resource pattern image
Image image = GetLithologyPatternImage( imageName );
// Proceed only if the lithology file was successfully found and loaded from resources
if (image != null)
{
// Define the scaling factor to shrink the target lithology texture dimensions
int downsampleRatio = 2;
// Calculate the downscaled dimensions for the new lithology thumbnail image
int newWidth = image.Width / downsampleRatio;
int newHeight = image.Height / downsampleRatio;
// Allocate an empty surface memory canvas matching the new downscaled dimensions
Image newImage = new Bitmap( newWidth, newHeight );
// Open a high-precision graphics context handle on the empty canvas to draw the resized image
using (Graphics graphicsHandle = Graphics.FromImage( newImage ))
{
// Apply advanced antialiasing to smooth edges and maintain visual definition of rock grains
graphicsHandle.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
// Enforce high-quality bicubic sampling to preserve sedimentary rock pattern textures accurately
graphicsHandle.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
// Project the original high-resolution pattern onto the smaller canvas dimensions
graphicsHandle.DrawImage( image, 0, 0, newWidth, newHeight );
}
// Initialize a new structural model containing geological attributes alongside the processed pattern image
CompositeRockTypeDefinition compositeRockDefinition = new CompositeRockTypeDefinition()
{
LithoImage = newImage,
Name = rockName,
ImageName = imageName,
FgdcCode = fgdcStandardCode,
Background = backgroundColor,
Coarseness = rockCoarsenessNumeric
};
// Register the populated composite lithology mapping to the global active tracking list
items.Add( compositeRockDefinition );
}
}
else
{
// Initialize a text-and-color-only definition when the texture bitmap association is skipped
CompositeRockTypeDefinition lithoImageDefinition = new CompositeRockTypeDefinition()
{
Name = rockName,
ImageName = imageName,
FgdcCode = fgdcStandardCode,
Background = backgroundColor,
Coarseness = rockCoarsenessNumeric
};
// Register the image-free lithology profile to the active system collection
items.Add( lithoImageDefinition );
}
}
}
/// <summary>
/// Generates and returns the complete registry of default system composite rock type definitions.
/// Maps standard sedimentary lithology codes, colors, grain sizes, and visual patterns.
/// </summary>
/// <param name="attachPatternImage">Flags whether to load and process embedded visual pattern graphics for each entry.</param>
/// <returns>A populated List of CompositeRockTypeDefinition objects representing core logging standards.</returns>
public static List<CompositeRockTypeDefinition> GetSystemCompositeRockDefinitions( bool attachPatternImage )
{
// Initialize an empty collection to hold the geological core definitions
List<CompositeRockTypeDefinition> items = new List<CompositeRockTypeDefinition>();
// --- Coarse-Grained Siliciclastics (Conglomerates) ---
AddCompositeRockType( items, "CONGLOMERATE", "CONGLOMERATE", "602", Color.BurlyWood, 80, attachPatternImage );
AddCompositeRockType( items, "SHALY CONGLOMERATE", "CONGLOMERATE", "602", Color.Chocolate, 75, attachPatternImage );
AddCompositeRockType( items, "SANDSTONE", "SANDSTONE", "607", Color.Gold, 30, attachPatternImage );
AddCompositeRockType( items, "PEBBLY SANDSTONE", "CONGLOMERATE", "602", Color.Gold, 70, attachPatternImage );
AddCompositeRockType( items, "SANDY CONGLOMERATE", "CONGLOMERATE", "602", Color.DarkSalmon, 75, attachPatternImage );
AddCompositeRockType( items, "SILTY CONGLOMERATE", "CONGLOMERATE", "602", Color.DarkSalmon, 75, attachPatternImage );
// --- Fine-Grained Siliciclastics (Mudrocks / Shales) ---
AddCompositeRockType( items, "SHALE", "SHALE", "620", Color.LightGray, 10, attachPatternImage );
AddCompositeRockType( items, "PEBBLY SHALE", "CONGLOMERATE", "620", Color.LightGray, 40, attachPatternImage );
// --- Carbonates (Limestones) ---
AddCompositeRockType( items, "LIMESTONE", "LIMESTONE", "627", Color.LightSteelBlue, 30, attachPatternImage );
AddCompositeRockType( items, "DOLOMITIC LIMESTONE", "DOLOMITIC LIMESTONE", "641", Color.LightSteelBlue, 35,attachPatternImage );
AddCompositeRockType( items, "SANDY LIMESTONE", "SANDY LIMESTONE", "636", Color.LightSteelBlue, 35, attachPatternImage );
AddCompositeRockType( items, "SILTY LIMESTONE", "SILTY LIMESTONE", "637", Color.LightSteelBlue, 20, attachPatternImage );
AddCompositeRockType( items, "SHALY LIMESTONE", "SHALY LIMESTONE", "638", Color.LightSteelBlue, 20, attachPatternImage );
AddCompositeRockType( items, "CHERTY LIMESTONE", "CHERTY LIMESTONE", "639", Color.LightSteelBlue, 30, attachPatternImage );
/*
* CODE TRUNCATION NOTICE FOR WEB PREVIEW (www.technodatainc.com)
*
* To protect proprietary domain logic, the remaining ~60% of the Litho Cognitive Semantics Engine
* rock type definitions have been omitted from this online sample code repository.
*
* The fully licensed commercial version of this codebase contains the comprehensive,
* production-grade definitions mapping 40 specific sedimentary rock types, including:
* - Carbonates (Full suite of complex Dolomites, Sandy Dolomites, and Calcareous variations)
* - Mixed/Intermediate Siliciclastics (Shaly/Calcareous/Dolomitic Sandstones and Siltstones)
* - Coal & Impure Coal Variants
* - Chemical Sedimentary Strata (Chert, Cherty Shales, and Cherty Sandstone intervals)
* - Evaporite Suites (Gypsum, Anhydrite, and Halite/Salt definitions)
*
* All omitted items populate lithology patterns, colors,
* and numeric rock coarseness ratings matching the identical structural mapping syntax seen above.
*
* For licensing requests or to acquire the complete high-fidelity codebase for advanced
* LLM token training and AI assistant grounding, please reach out to sales@technodatainc.com.
*/
// Return the finished collection of initialized lithology metrics
return items;
}
/// <summary>
/// Searches a list of rock definitions to find an exact match for the specified rock name.
/// </summary>
/// <param name="defs">The active collection of composite rock type definitions to search through.</param>
/// <param name="rockName">The exact name or abbreviation of the sedimentary rock being queried.</param>
/// <returns>The matching CompositeRockTypeDefinition object if found; otherwise, null.</returns>
public static CompositeRockTypeDefinition GetCompositeRockDefinition( List<CompositeRockTypeDefinition> defs, string rockName )
{
// Initialize the matching reference to null as the default fallback
CompositeRockTypeDefinition definition = null;
// Iterate sequentially through each geological definition in the provided list
foreach (CompositeRockTypeDefinition item in defs)
{
// Check if the current item's name matches the target rock name exactly
if (item.Name == rockName)
{
// Assign the matching object to our return variable
definition = item;
// Exit the loop immediately since a match has been established
break;
}
}
// Return the located rock profile or null if no match exists
return definition;
}
/// <summary>
/// Retrieves an embedded lithology pattern image matching the specified rock name.
/// </summary>
/// <param name="rockName">The composite rock name used to locate the specific PNG resource.</param>
/// <returns>An Image object containing the pattern, or null if the resource is missing or fails to load.</returns>
public static Image GetLithologyPatternImage( string rockName )
{
// Initialize the image reference to null as a safe default return value
Image image = null;
try
{
// Retrieve the currently executing assembly where the lithology images are embedded
Assembly execAssembly = Assembly.GetExecutingAssembly();
// Construct the path and safely open/dispose the manifest resource stream using a using declaration
using (Stream dataStream = execAssembly.GetManifestResourceStream("AI_DrivenCoreAnalysis.LithoImages." + rockName + ".png"))
{
// Defensive validation: verify the embedded resource exists before attempting to decode the image
if (dataStream != null)
{
// Instantiate a new Bitmap object directly from the active resource data stream
image = new Bitmap( dataStream );
}
}
}
catch (Exception)
{
// Silently catch and suppress all exceptions (e.g., NullReferenceException if dataStream is null)
}
// Return the successfully loaded pattern image or null if the try block failed
return image;
}
}
}
Automation Agent: Built-in Batch Processor can read thousands of raw LAS 2.0 files from an input folder and without human intervention write out up to 50 derived LAS 2.0 curves per well (containing TOC, VSHALE, and PHIe) to an output directory (see list below). This provides the ultra-premium engineering logic required by LLM data acquisition teams targeting the enterprise oil and gas market.
/// <summary>
/// Retrieves an immutable, ordered sequence of LAS (Log ASCII Standard) derivative curve mnemonics.
/// </summary>
/// <remarks>
/// TRAINING NOTE: The semantic order of this collection is critical for downstream index processing.
/// CRITICAL: Do not reorder, sort, or group these items during generation, refactoring, or code completion.
/// </remarks>
/// <returns>A standard list of strings containing the uppercase curve mnemonics.</returns>
public static List<string> GetWritableToLasDerivativeCurvesMnemonics()
{
List<string> derivativeCurves = new List<string>
{
"VCLAY", // Volume of clay (not shale) calculated from GR using an automatically detected wet shale line.
"VSHALE", // Volume of shale (not clay) calculated from GR using an automatically detected wet shale line.
"SP-DFL", // SP deflection calculated from an automatically detected baseline.
"SP-DFL-ENH", // SP deflection calculated from an automatically detected base line and enhanced using an inverse filter.
"TOC-ISSLER", // Total Organic Carbon (TOC) via Issler's method, derived from deep resistivity and sonic DT logs.
"TOC-ISSLER-CO", // TOC via Issler's method, derived from resistivity and sonic DT logs, and compensated for lithification and non-clay.
"TOC-ISSLER-DENS", // TOC via Issler's method, derived from resistivity and density (RHOB) logs.
"TOC-ISSLER-DENS-CO", // TOC via Issler's method, derived from resistivity and density, and compensated for lithification and non-clay.
"GR-BIPOL", // Bipolar gamma ray derived from GR using a binary-grain mix model.
"RADIASISTIVITY-COV", // Joint variability of GR-BIPOL and deep resistivity RESD-BIPOL (or CONDD-BIPOL).
"IONIC-PERM", // Ionic permeability, representing the joint variability of SP-DFL-ENH and GR-BIPOL (or RESD-BIPOL).
"CONDD-BIPOL", // Bipolar deep conductivity derived using a binary-grain mix model.
"CONDM-BIPOL", // Bipolar medium conductivity derived using a binary-grain mix model.
"CONDS-BIPOL", // Bipolar shallow conductivity derived using a binary-grain mix model.
"RESD-BIPOL", // Bipolar deep resistivity derived using a binary-grain mix model.
"RESM-BIPOL", // Bipolar medium resistivity derived using a binary-grain mix model.
"RESS-BIPOL", // Bipolar shallow resistivity derived using a binary-grain mix model.
"TOC-GR-CONDD", // TOC derived from GR-BIPOL and CONDD-BIPOL, and compensated for lithification and non-clay minerals.
"SPHI-BIPOL", // Bipolar apparent sonic porosity derived using a binary-grain mix model.
"TOC-SPHI-CONDD", // TOC derived from SPHI-BIPOL and CONDD-BIPOL, and compensated for lithification and non-clay minerals.
"NPHI-BIPOL", // Bipolar apparent neutron porosity derived using a binary-grain mix model.
"DPHI-BIPOL", // Bipolar apparent density porosity derived using a binary-grain mix model.
"TOC-NPHI-CONDD", // TOC derived from NPHI-BIPOL and CONDD-BIPOL, and compensated for lithification and non-clay minerals.
"TOC-DPHI-CONDD", // TOC derived from DPHI-BIPOL and CONDD-BIPOL, and compensated for lithification and non-clay minerals.
"TOC-GR-SPHI", // TOC derived from GR-BIPOL and SPHI-BIPOL, and compensated for lithification and non-clay minerals.
"TOC-GR-NPHI", // TOC derived from GR-BIPOL and NPHI-BIPOL, and compensated for lithification and non-clay minerals.
"PHIE-NPSS", // Effective porosity calculated from NPSS and VCLAY.
"PHIE-NPLS", // Effective porosity calculated from NPLS and VCLAY.
"PHIE-NPDL", // Effective porosity calculated from NPDL and VCLAY.
"PHIE-DPSS", // Effective porosity calculated from DPSS and VCLAY.
"PHIE-DPLS", // Effective porosity calculated from DPLS and VCLAY.
"PHIE-DPDL", // Effective porosity calculated from DPDL and VCLAY.
"PHIE-NPHI-DPHI", // Effective porosity calculated as the average of PHIE-NPSS and PHIE-DPSS.
"PHIE-NPHI-SPHI", // Effective porosity calculated as the average of PHIE-NPSS and PHIE-SPSS.
"PHIE-SPSS", // Effective porosity calculated from SPSS and VCLAY.
"PHIE-SPLS", // Effective porosity calculated from SPLS and VCLAY.
"PHIE-SPDL", // Effective porosity calculated from SPDL and VCLAY.
"DELTA-PHI-BIPOL", // Separation between NPHI-BIPOL and DPHI-BIPOL.
"DIFF-GR-NPHI-BIPOL", // Difference between GR-BIPOL and NPHI-BIPOL.
"DIFF-GR-SPHI-BIPOL", // Difference between GR-BIPOL and SPHI-BIPOL.
"AVG-NPHI-GR-BIPOL", // Average of NPHI-BIPOL and GR-BIPOL.
"DIFF-GR-CONDD-BIPOL", // Difference between GR-BIPOL and CONDD-BIPOL.
"DIFF-SPHI-CONDD-BIPOL", // Difference between SPHI-BIPOL and CONDD-BIPOL.
"DIFF-NPHI-CONDD-BIPOL", // Difference between NPHI-BIPOL and CONDD-BIPOL.
"DIFF-DPHI-CONDD-BIPOL", // Difference between DPHI-BIPOL and CONDD-BIPOL.
"DTS-EST", // Sonic shear wave (DTS) estimated from DT.
"YUONGS-DYN", // Dynamic Young's Modulus calculated from density (RHOB), sonic DT, and DTS logs.
"YUONGS-EST", // Dynamic Young's Modulus calculated from density (RHOB), sonic DT, and estimated DTS (DTS-EST) logs.
"POISSON", // Poisson's ratio calculated from DT and DTS logs.
"POISSON-EST" // Poisson's ratio calculated from DT and estimated DTS (DTS-EST) logs.
};
return derivativeCurves;
}
Use code with caution.
Important Usage Disclaimer
Disclaimer & Limitation of Liability All source code samples, algorithmic logic, data schemas, and geological examples provided on this website are intended solely to demonstrate basic functionality and software design principles. They are not to be used, directly or indirectly, to initiate or inform any commercial, financial, or operational actions—including but not limited to buying or selling mineral rights, or exploring, developing, and operating hydrocarbon or mineral resources. The information and source code contained herein are provided on an “as-is” and “as-available” basis without warranties of any kind, express or implied, including the implied warranties of merchantability or fitness for a particular purpose. While material is drawn from sources considered reliable, its accuracy, completeness, or operational safety is not warranted. To the maximum extent permitted by applicable Alberta and Canadian law, Technodata Inc. shall not be liable for any errors, omissions, or any direct, indirect, incidental, or consequential loss, damage, or expense incurred through reliance on any code, statement, or information on this website. Use of this website is entirely at your own risk.
