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

Axial Load, Drag, Sinusoidal and Helical Buckling vs Depth

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

Broomstick (Hookload) modeled (4 frictions factors), Hookload real (dots) vs Depth. Each Dot color represents different rig states.

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

BHA Schematic vs Neutral Point - Compression (Red), Tension (Blue)

Neutral Point, Top BHA and Bit Depth vs Time

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)