@equinor/esv-intersection 3.0.4 → 3.0.7

package/src/layers/schematicInterfaces.ts

@@ -0,0 +1,472 @@
+import { SHOE_LENGTH, SHOE_WIDTH } from '../constants';
+
+export function assertNever(x: never): never {
+  throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
+}
+
+/**
+ * The closure type of the outline
+ */
+export type OutlineClosure = 'None' | 'TopAndBottom' | 'Top' | 'Bottom';
+
+export interface HoleSize {
+  kind: 'hole';
+  id: string;
+  diameter: number;
+  start: number;
+  end: number;
+}
+
+export interface CasingWindow {
+  id: string;
+  start: number;
+  end: number;
+}
+
+export interface Casing {
+  kind: 'casing';
+  id: string;
+  diameter: number;
+  start: number;
+  end: number;
+  hasShoe: boolean;
+  innerDiameter: number;
+  windows?: CasingWindow[];
+}
+
+interface SymbolComponent {
+  id: string;
+  diameter: number;
+  start: number;
+  end: number;
+  symbolKey: string;
+}
+
+export interface PAndASymbol extends SymbolComponent {
+  kind: 'pAndASymbol';
+}
+
+export const isPAndASymbol = (item: PAndA): item is PAndASymbol => item.kind === 'pAndASymbol';
+
+export interface CementSqueeze {
+  kind: 'cementSqueeze';
+  id: string;
+  start: number;
+  end: number;
+  /**
+   * Referenced Casing and Completion ids
+   */
+  referenceIds: string[];
+}
+
+export const isCementSqueeze = (item: PAndA): item is CementSqueeze => item.kind === 'cementSqueeze';
+
+export interface CementPlug {
+  kind: 'cementPlug';
+  id: string;
+  start: number;
+  end: number;
+  /**
+   * Referenced Casing, Completion ids
+   */
+  referenceIds: string[];
+}
+
+export const isCementPlug = (item: PAndA): item is CementSqueeze => item.kind === 'cementPlug';
+
+export type PAndA = PAndASymbol | CementSqueeze | CementPlug;
+
+interface BaseCompletion {
+  id: string;
+  diameter: number;
+  start: number;
+  end: number;
+}
+
+export interface Screen extends BaseCompletion {
+  kind: 'screen';
+}
+export interface Tubing extends BaseCompletion {
+  kind: 'tubing';
+}
+
+export interface CompletionSymbol extends BaseCompletion {
+  kind: 'completionSymbol';
+  symbolKey: string;
+}
+
+export type Completion = Tubing | Screen | CompletionSymbol;
+
+export const foldCompletion =
+  <T>(fScreen: (obj: Screen) => T, fTubing: (obj: Tubing) => T, fSymbol: (obj: CompletionSymbol) => T) =>
+  (completion: Completion): T => {
+    switch (completion.kind) {
+      case 'screen':
+        return fScreen(completion);
+      case 'tubing':
+        return fTubing(completion);
+      case 'completionSymbol':
+        return fSymbol(completion);
+      default:
+        return assertNever(completion);
+    }
+  };
+
+export interface Cement {
+  kind: 'cement';
+  id: string;
+  /**
+   *  Referenced Casing and Completion ids
+   */
+  referenceIds: string[];
+  toc: number;
+}
+
+/**
+ * 'Open hole' and 'Open hole screen' are not included as they are not visualized and also not included in the ruleset
+ */
+export type PerforationSubKind =
+  | 'Perforation'
+  | 'Open hole gravel pack'
+  | 'Open hole frac pack'
+  | 'Cased hole frac pack'
+  | 'Cased hole gravel pack'
+  | 'Cased hole fracturation';
+
+export interface Perforation {
+  kind: 'perforation';
+  subKind: PerforationSubKind;
+  id: string;
+  start: number;
+  end: number;
+  /**
+   * is the perforation open or sealed?
+   */
+  isOpen: boolean;
+}
+
+export const foldPerforationSubKind = <T>(
+  options: {
+    Perforation: (kind: 'Perforation') => T;
+    OpenHoleGravelPack: (kind: 'Open hole gravel pack') => T;
+    OpenHoleFracPack: (kind: 'Open hole frac pack') => T;
+    CasedHoleGravelPack: (kind: 'Cased hole gravel pack') => T;
+    CasedHoleFracPack: (kind: 'Cased hole frac pack') => T;
+    CasedHoleFracturation: (kind: 'Cased hole fracturation') => T;
+  },
+  subKind: PerforationSubKind,
+) => {
+  switch (subKind) {
+    case 'Perforation':
+      return options.Perforation(subKind);
+
+    case 'Open hole gravel pack':
+      return options.OpenHoleGravelPack(subKind);
+
+    case 'Open hole frac pack':
+      return options.OpenHoleFracPack(subKind);
+
+    case 'Cased hole fracturation':
+      return options.CasedHoleFracturation(subKind);
+
+    case 'Cased hole frac pack':
+      return options.CasedHoleFracPack(subKind);
+
+    case 'Cased hole gravel pack':
+      return options.CasedHoleGravelPack(subKind);
+
+    default:
+      return assertNever(subKind);
+  }
+};
+
+export const shouldPerforationStartAtHoleDiameter = (perf: Perforation) =>
+  foldPerforationSubKind(
+    {
+      Perforation: () => true,
+      OpenHoleGravelPack: () => true,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+
+export const shouldPerforationStartAtCasingDiameter = (perf: Perforation) =>
+  foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => true,
+      CasedHoleGravelPack: () => true,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+
+export const hasPacking = (perf: Perforation): boolean =>
+  foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => true,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => true,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+
+export function hasFracLines(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => true,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+}
+
+export function hasSpikes(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => true,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+}
+
+export function isSubkindCasedHoleGravelPack(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => true,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+}
+
+export function isSubKindPerforation(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => true,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+}
+
+export function isSubKindCasedHoleFracPack(perf: Perforation): boolean {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => false,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => true,
+    },
+    perf.subKind,
+  );
+}
+
+export function isOpenHoleFracPack(perf: Perforation) {
+  return foldPerforationSubKind(
+    {
+      Perforation: () => false,
+      OpenHoleGravelPack: () => false,
+      OpenHoleFracPack: () => true,
+      CasedHoleFracturation: () => false,
+      CasedHoleGravelPack: () => false,
+      CasedHoleFracPack: () => false,
+    },
+    perf.subKind,
+  );
+}
+
+export const isSubKindCasedHoleFracturation = (perf: Perforation): boolean => perf.subKind === 'Cased hole fracturation';
+
+export const intersect = (a: Perforation, b: Perforation): boolean => {
+  return a.start < b.end && a.end > b.start;
+};
+
+export interface SchematicData {
+  holeSizes: HoleSize[];
+  casings: Casing[];
+  cements: Cement[];
+  completion: Completion[];
+  pAndA: PAndA[];
+  symbols: {
+    [key: string]: string;
+  };
+  perforations: Perforation[];
+}
+
+export interface InternalLayerOptions {
+  holeLayerId: string;
+  casingLayerId: string;
+  completionLayerId: string;
+  cementLayerId: string;
+  pAndALayerId: string;
+  perforationLayerId: string;
+}
+
+export const defaultInternalLayerOptions = (layerId: string): InternalLayerOptions => ({
+  holeLayerId: `${layerId}-hole`,
+  casingLayerId: `${layerId}-casing`,
+  completionLayerId: `${layerId}-completion`,
+  cementLayerId: `${layerId}-cement`,
+  pAndALayerId: `${layerId}-pAndA`,
+  perforationLayerId: `${layerId}-perforation`,
+});
+
+export interface HoleOptions {
+  firstColor: string;
+  secondColor: string;
+  lineColor: string;
+}
+
+export const defaultHoleOptions: HoleOptions = {
+  firstColor: '#8c541d',
+  secondColor: '#eee3d8',
+  lineColor: '#8b4513',
+};
+
+export interface CasingShoeSize {
+  width: number;
+  length: number;
+}
+
+export interface WindowOptions {
+  dashColor: string;
+  dashLength: number;
+  spaceLength: number;
+}
+
+export interface CasingOptions {
+  solidColor: string;
+  lineColor: string;
+  shoeSize: CasingShoeSize;
+  windowOptions: WindowOptions;
+}
+
+export const defaultCasingOptions: CasingOptions = {
+  solidColor: '#dcdcdc',
+  lineColor: '#575757',
+  shoeSize: {
+    width: SHOE_WIDTH,
+    length: SHOE_LENGTH,
+  },
+  windowOptions: {
+    dashColor: '#dc0000',
+    dashLength: 5,
+    spaceLength: 3,
+  },
+};
+
+export interface PerforationOptions {
+  stroke: string;
+  yellow: string;
+  grey: string;
+  red: string;
+  outline: string;
+  transparent: string;
+  spikeWidth: number;
+  spikeLength: number;
+  packingOpacity: number;
+  fracLineLength: number;
+  fracLineCurve: number;
+  scalingFactor: number;
+}
+
+export const defaultPerforationOptions: PerforationOptions = {
+  stroke: 'rgba(0, 0, 0, 0.25)',
+  yellow: '#FFFC00',
+  grey: 'gray',
+  red: '#FF5050',
+  outline: 'black',
+  transparent: 'rgba(255, 255, 255, 0)',
+  spikeWidth: 50,
+  spikeLength: 50,
+  packingOpacity: 0.7,
+  fracLineCurve: 10,
+  fracLineLength: 25,
+  scalingFactor: 25,
+};
+
+export interface CementOptions {
+  firstColor: string;
+  secondColor: string;
+  scalingFactor: number;
+}
+
+export const defaultCementOptions: CementOptions = {
+  firstColor: '#c7b9ab',
+  secondColor: '#5b5b5b',
+  scalingFactor: 4,
+};
+
+export interface CementSqueezeOptions {
+  firstColor: string;
+  secondColor: string;
+  scalingFactor: number;
+}
+
+export const defaultCementSqueezeOptions: CementSqueezeOptions = {
+  firstColor: '#8b6713',
+  secondColor: '#000000',
+  scalingFactor: 4,
+};
+
+export interface ScreenOptions {
+  scalingFactor: number;
+  lineColor: string;
+}
+
+export const defaultScreenOptions: ScreenOptions = {
+  scalingFactor: 4,
+  lineColor: '#63666a',
+};
+
+export interface TubingOptions {
+  innerColor: string;
+  outerColor: string;
+  scalingFactor: number;
+}
+
+export const defaultTubingOptions: TubingOptions = {
+  scalingFactor: 1,
+  innerColor: '#eeeeff',
+  outerColor: '#777788',
+};
+
+export interface CementPlugOptions {
+  firstColor: string;
+  secondColor: string;
+  scalingFactor: number;
+}
+
+export const defaultCementPlugOptions: CementPlugOptions = {
+  firstColor: '#c7b9ab',
+  secondColor: '#000000',
+  scalingFactor: 4,
+};

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "declarationDir": "../dist",
+    "emitDeclarationOnly": true,
+    "rootDir": "."
+  },
+  "include": ["."]
+}

package/src/utils/arc-length.ts

@@ -0,0 +1,66 @@
+import Vector2 from '@equinor/videx-vector2';
+import { Vector } from 'curve-interpolator/dist/src/core/interfaces';
+
+type fx = (n: number) => Vector;
+
+/*
+ * Methods for calculating length of a curve
+ */
+export class ArcLength {
+  /**
+   * Calculate using an adaptive bisect method
+   * @param {Number} func Curve function returning [x,y]
+   * @param {Number} minLimit Min limit
+   * @param {Number} maxLimit Max limit
+   * @param {Number} tolerance Result tolerance
+   * @param {Number} minDepth Min recursive depth before accepting solution
+   * @param {Number} maxDepth Max recursive depth
+   */
+  static bisect(
+    func: fx,
+    minLimit: number = 0,
+    maxLimit: number = 1,
+    tolerance: number = 0.005,
+    minDepth: number = 4,
+    maxDepth: number = 10,
+  ): number {
+    const calcRec = (a: number, b: number, aVal: number[], bVal: number[], span: number, tolerance: number, depth: number = 0): number => {
+      const mid = (a + b) / 2;
+      const midVal = func(mid) as number[];
+      const spanA = Vector2.distance(aVal, midVal);
+      const spanB = Vector2.distance(midVal, bVal);
+      const length = spanA + spanB;
+      if ((depth >= minDepth && Math.abs(length - span) < tolerance) || depth >= maxDepth) {
+        return length;
+      }
+      const tol = tolerance / 2;
+      const d = depth + 1;
+      return calcRec(a, mid, aVal, midVal, spanA, tol, d) + calcRec(mid, b, midVal, bVal, spanB, tol, d);
+    };
+    const aVal = func(minLimit) as number[];
+    const bVal = func(maxLimit) as number[];
+    const span = Vector2.distance(aVal, bVal);
+    const res = calcRec(minLimit, maxLimit, aVal, bVal, span, tolerance);
+    return res;
+  }
+
+  /**
+   * Calculate using trapezoid method
+   * @param {Number} func Curve function returning [x,y]
+   * @param {Number} minLimit Min limit
+   * @param {Number} maxLimit Max limit
+   * @param {Number} segments Number of segments
+   */
+  static trapezoid(func: fx, minLimit: number = 0, maxLimit: number = 1, segments: number = 1000): number {
+    let length = 0;
+    let lastPos = func(minLimit) as number[];
+    const step = (maxLimit - minLimit) / (segments - 1);
+    for (let i = 1; i < segments; i++) {
+      const pos = func(minLimit + i * step) as number[];
+      const delta = Vector2.distance(lastPos, pos);
+      length += delta;
+      lastPos = pos;
+    }
+    return length;
+  }
+}

package/src/utils/binary-search.ts

@@ -0,0 +1,26 @@
+/**
+ * Find index where value[index] =< searchValue and value[index+1] >= searchValue using binary search
+ * @param {Number} values Array of sorted values
+ * @param {Number} searchValue Value to search for
+ */
+export class BinarySearch {
+  static search(values: number[], searchValue: number): number {
+    let il = 0;
+    let ih = values.length - 1;
+    let i = Math.floor(il + ih / 2);
+    while (i > il && i < ih) {
+      const v = values[i];
+      const v1 = values[i + 1];
+      if (v <= searchValue && v1 >= searchValue) {
+        return i;
+      }
+      if (searchValue < v) {
+        ih = i;
+      } else {
+        il = i;
+      }
+      i = Math.floor(il + ih / 2);
+    }
+    return i;
+  }
+}

package/src/utils/color.ts

@@ -0,0 +1,22 @@
+import { color, Color } from 'd3-color';
+
+const RADIX_SIXTEEN = 16;
+const HEX_STRING_LENGTH = 6;
+/**
+ * Convert color string to number
+ */
+export function convertColor(colorStr: string): number {
+  const c: Color = color(colorStr);
+  const d: string = c.formatHex();
+  const n: number = parseInt(d.replace('#', '0x'));
+  return n;
+}
+
+export function colorToCSSColor(color: number | string): string {
+  if (typeof color === 'string') {
+    return color;
+  }
+
+  const colorHexString = color.toString(RADIX_SIXTEEN);
+  return `#${colorHexString.padStart(HEX_STRING_LENGTH, '0')}`;
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './text';

package/src/utils/root-finder.ts

@@ -0,0 +1,78 @@
+import { clamp } from '@equinor/videx-math';
+
+type fx = (n: number) => number;
+
+/*
+ * Methods for finding root of a function
+ */
+export class RootFinder {
+  /**
+   * Find root using newthons method
+   * @param {Number} func f(x)
+   * @param {Number} precision Accuracy of result
+   * @param {Number} maxIterations Max number of iterations to use
+   * @param {Number} start Starting position
+   * @param {Number} minLimit Min limit of result
+   * @param {Number} maxLimit Max limit of result
+   */
+  static newton(func: fx, precision: number = 0.01, maxIterations: number = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number {
+    const h = 0.0001;
+    let t = start;
+    for (let i = 0; i < maxIterations; i++) {
+      const v = func(t);
+      if (Math.abs(v) < precision) {
+        return clamp(t, minLimit, maxLimit);
+      }
+      const d = (func(t + h) - v) / h;
+      t = t - v / d;
+    }
+    return null;
+  }
+
+  /**
+   * Find root using bisect method
+   * @param {Number} func f(x)
+   * @param {Number} precision Accuracy of result
+   * @param {Number} maxIterations Max number of iterations to use
+   * @param {Number} start Starting position
+   * @param {Number} minLimit Min limit of result
+   * @param {Number} maxLimit Max limit of result
+   */
+  static bisect(func: fx, precision: number = 0.01, maxIterations: number = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number {
+    let tl = minLimit;
+    let th = maxLimit;
+    let t = start;
+    let v;
+    let i;
+    for (i = 0; i < maxIterations; i++) {
+      v = func(t);
+      if (Math.abs(v) < precision) {
+        return t;
+      }
+      if (v < 0) {
+        th = t;
+      } else {
+        tl = t;
+      }
+      t = (th + tl) / 2;
+    }
+    return t;
+  }
+
+  /**
+   * Find root by trying available methods
+   * @param {Number} func f(x)
+   * @param {Number} precision Accuracy of result
+   * @param {Number} maxIterations Max number of iterations to use
+   * @param {Number} start Starting position
+   * @param {Number} minLimit Min limit of result
+   * @param {Number} maxLimit Max limit of result
+   */
+  static findRoot(func: fx, precision: number = 0.01, maxIterations: number = 1000, start = 0.5, minLimit = 0, maxLimit = 1): number {
+    let t = RootFinder.newton(func, precision, maxIterations, start);
+    if (t == null) {
+      t = RootFinder.bisect(func, precision, maxIterations, start, minLimit, maxLimit);
+    }
+    return t;
+  }
+}