Pipes Functions

Forces

All curves

Computes the normal, axial load, drag, and torque over all the well layers

og.model.softString.torqueAndDrag(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "torqueOnBit", value_N.m, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Outputs:

  • True Axial Load (N)

  • Drag (N)

  • Normal (N)

  • vs Depth(m)

Normal

Calculates a map of the side forces (normal) of the specified well

og.model.softString.normal(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "torqueOnBit", value_N.m, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Normal (N) vs Depth(m)

Normal per Length

og.model.softString.normalPerLength(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "torqueOnBit", value_N.m, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Normal per Length Forces (N/m) vs Depth(m)

Drag

Computes the drag values of the specified well

og.model.softString.drag(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Drag (N) vs Depth(m)

Torque

Computes the torque values of the specified well

og.model.softString.torque(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "torqueOnBit", value_N.m, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Torque (N.m) vs Depth(m)

Axial load

Computes the axial load values of the specified well

og.model.softString.axialLoad(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: True Axial Load (N) vs Depth(m)

Effective Axial Load

Computes the effective axial load values of the specified well

og.model.softString.effectiveAxialLoad(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Effective Axial Load (N) vs Depth(m)

Stress

Computes the stress values of the specified well

og.model.softString.stress(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "torqueOnBit", value_N.m, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3)
                "stressType", "String")
)

Output: Stress (Pa) vs Depths (m)

Possible stress types:

  • TRANSVERSE_SHEAR,

  • RADIAL,

  • HOOP,

  • BUCKLING,

  • AXIAL,

  • VON_MISES

  • BENDING

  • TORSIONAL

Buckling

Sinusoidal

Computes the sinusoidal buckling values of the specified well

og.model.softString.sinusoidalBuckling(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "maxSectionLength",value_m)
)

Output: Sinusoidal Buckling (N) vs Depth(m)

Helical

Computes the helical buckling values of the specified well

og.model.softString.helicalBuckling(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "maxSectionLength",value_m)
)

Output: Helical Buckling (N) vs Depth(m)

Broomstick Charts

Hook load

Computes the hook load

og.model.softString.hookLoad(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "stepLength", value_m, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s,  
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Hook Loads (N) vs Depth (m)

Minimum Weight Helical Buckling

Computes the Minimum Weight Helical Buckling

og.model.softString.hookLoadForBuckling(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "stepLength", value_m, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s,  
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Hook Load For Helical Buckling (N) vs Depths (m)

Maximum weight for Yield Strength

Computes the Maximum weight for Yield Strength

og.model.softString.hookLoadForMaterialFailure(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "stepLength", value_m, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s,  
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: HookLoad For Material Failure (N) vs Depths (m)

Torque on Surface

Computes the torque on surface

og.model.softString.torqueOnSurface(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "stepLength", value_m, 
                "torqueOnBit", value_N.m, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s,  
                "startFromSurface", boolean, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Torque on Surface (N) vs Depths (m)

Find Positions

Neutral Point

Computes all the neutral points locations

og.model.softString.neutralPoint(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "travellingBlockWeight", value_N, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "startFromSurface", boolean, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Neutral point (m)

Stretch

Computes the stretch value of the specified well

og.model.softString.stretch(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "fluidFlow", value_m3/s,
                "frictionFactor", value,
                "frictionFactorMap", value,
                "maxSectionLength",value_m, 
                "useCalibrationData", boolean, 
                "pipesWeightMultiplier", value, 
                "rotarySpeed",  value_rad/s, 
                "columnVelocity", value_m/s, 
                "weightOnBit", value_N, 
                "hookLoad", value_N, 
                "pipeDensityMap", newmap(m,kg/m3), 
                "annularDensityMap", newmap(m,kg/m3))
)

Output: Stretch (m)

Stuck Pipe Position (Free point calculation)

Computes the stuck pipe position (m) given a hook load delta (N) and the respective stretch (m)

og.model.softString.stuckPipePosition(
         newmap("wellId", "{well_id}",  
                "bitDepth", value_m,
                "stretch", value_m,
                "hookLoadDelta", value_N)
)

Output: Position (m)

Input Parameters Description

Input Parameters

Parameters

Description

unit

wellId

Well id

String

weightOnBit

Weight on bit (downhole)(default: zero)

N

rotarySpeed

Angular Speed (RPM) (default: zero)

rad/s

columnVelocity

Drill string or Casing Velocity (default: zero)

m/s

frictionFactor

Friction Factor (default: zero)

[-]

frictionFactorMap

Add map friction factor along the string, e.g: newmap(0.0, friction1, MD2, friction2).

(m, -)

bitDepth

Bottom Depth (bit depth) (default: original Md of Drillstring)

m

torqueOnBit

Torque on Bit (Downhole) (default: zero)

N.m

fluidFlow

Flow Rate/pump flow in (default: zero)

m3/s

stepLength

Mesh discretization Step length (default: 1000m)

m

usCalibrationData

Calibratable (default: False)

Boolean

maxSectionLength

Max Section Length (default:200m)

m

startFromSurface

Calculate from the surface (Top to bottom) default: False

Boolean

hookLoad

Hook Load (default empty)

N

travellingBlockWeight

Traveling Block Weight (default: zero)

N

pipesWeightMultiplier

Pipes Weight Multiplier, it is the coefficient to multiply linear weight of DP (default:1.0)

[-]

pipeDensityMap

Add map density within pipe,

e.g: newmap(0.0, density1, MD2, density2). This is an important feature to multiple fluids

(m,kg/m3)

annularDensityMap

Add map density within pipe,

e.g: newmap(0.0, density1, MD2, density2). This is an important feature of multiple fluids.

(m,kg/m3)

PreviousStatic Data DependenciesNextHole Cleaning

Last updated