Class CutterBeamCompliance
The compliance of one exposed cutter beam as a function of where its load
sits: the beam is the cantilever gripped at the holder (z = L, the
exposed height) that GetBeamCompliance() builds
from the flute core and the exposed upper beam, sliced section by section
at each section's mean radius. For a lateral unit force at height
a from the tip the tip deflects
C(a) = ∫ₐᴸ (z − a)·z / (E·I(z)) dz, I = π·r⁴/4 (unit-load method:
the real moment (z − a) above the load, the virtual moment z of a unit tip
force; the beam below the load carries no moment and moves with it as a
rigid body); for an axial unit force at that height the tip shortens
Cz(a) = ∫ₐᴸ 1 / (E·A(z)) dz, A = π·r². With E in GPa and lengths in
mm both read in µm/N. C is convex and decreasing from the tip to the grip;
at the tip, a = 0, it is the plain tip compliance (L³/(3·E·I) on a
cylinder). A cutter whose beam comes to a point — a cone, a drill, a V
bit: a straight flank meeting the axis — has no tip compliance: the
integrand grows as 1/z² into the apex and the integral has no limit, so
TipBendingPara_umdN and TipZDeflectionPara_umdN
are NaN there instead of the number the slice width
happens to produce, while the compliance for a load at any height above
the apex is finite and settles as the slices thin (within 0.5 % at a =
0.5 mm on a Ø25 60° countersink between 0.1 mm and 0.01 mm slices, within
0.01 % from 5 mm up). A ball cutter's contour starts on the axis as well,
but its tip integral converges (on the sphere z²/r⁴ = 1/(2R − z)²) and it
keeps its tip values. The cumulative integrals are kept at every slice
knot and the slice holding a is integrated in closed form, so the
evaluation is exact within the sliced beam at any height — nothing
interpolates a function that varies as 1/z.
public sealed class CutterBeamCompliance- Inheritance
-
CutterBeamCompliance
- Inherited Members
- Extension Methods
Properties
ExposedHeight_mm
The grip height from the tip, mm: the beam ends here.
public double ExposedHeight_mm { get; }Property Value
IsPointed
Whether the beam comes to a point at the tip — a straight flank meeting the axis, as a cone, a drill or a V bit has — so that a load at the tip has no compliance to state: the integrand grows as 1/z² into the apex. A ball cutter's contour starts on the axis too, but on its sphere r² = z·(2R − z) and the tip integral converges; the builder is told which it is (Build(IEnumerable<PairZr>, double, double, bool)).
public bool IsPointed { get; }Property Value
SliceCount
The number of slices the beam was integrated over.
public int SliceCount { get; }Property Value
TipBendingPara_umdN
The lateral compliance for a load at the tip, GetBendingPara_umdN(0): NaN on a pointed beam.
public double TipBendingPara_umdN { get; }Property Value
TipRadius_mm
The beam's radius at its first contour point, mm: 0 when the contour starts on the axis, which a pointed cutter's does and a ball cutter's does too.
public double TipRadius_mm { get; }Property Value
TipZDeflectionPara_umdN
The axial compliance for a load at the tip, GetZDeflectionPara_umdN(double)(0): NaN on a pointed beam.
public double TipZDeflectionPara_umdN { get; }Property Value
Methods
Build(IEnumerable<PairZr>, double, double, bool)
Builds the compliance of a beam contour. The contour is the inner beam
continued by the exposed upper beam, ascending in z from the tip to the
grip; it is sliced to sliceResolution_mm and each
slice is a section of its mean radius: a section of constant radius is
exact, a tapered one approximated.
public static CutterBeamCompliance Build(IEnumerable<PairZr> beamContour, double elasticModulus_GPa, double sliceResolution_mm, bool pointedApex)Parameters
beamContourIEnumerable<PairZr>The (z, r) contour from the tip to the grip, at least two points.
elasticModulus_GPadoubleE of the beam material, GPa.
sliceResolution_mmdoubleThe largest slice height, mm; positive.
pointedApexboolWhether the contour leaves the tip along a straight flank from the axis (IsPointed); a contour whose first point has a radius is never pointed, whatever is passed.
Returns
- CutterBeamCompliance
The compliance, never null.
Exceptions
- ArgumentException
The contour has fewer than two points, or no section of positive height.
GetBendingPara_umdN(double)
The lateral tip deflection per unit lateral force applied at
loadHeight_mm above the tip, µm/N:
∫ₐᴸ (z − a)·z / (E·I) dz. 0 for a load at or above the grip;
a negative height reads as the tip; NaN for a NaN
height, and for a load at the tip of a pointed beam.
public double GetBendingPara_umdN(double loadHeight_mm)Parameters
loadHeight_mmdouble
Returns
GetBendingPara_umdN(double, double)
The lateral deflection at observationHeight_mm above
the tip per unit lateral force applied at
loadHeight_mm above the tip, µm/N:
∫ (z − a)·(z − h) / (E·I) dz from max(a, h) to the grip (the
real moment of the load times the virtual moment of a unit force at the
observed height; below either height one of them is 0). It is what a
sensor or a machined surface at height h reads, where
GetBendingPara_umdN(double) reads the tip: symmetric in
the two heights (Maxwell's reciprocity), equal to that tip value at
h = 0, 0 when either height is at or above the grip.
NaN for a NaN height, and on a pointed beam when
both heights are the tip; a load at a pointed tip observed above it is
finite.
public double GetBendingPara_umdN(double loadHeight_mm, double observationHeight_mm)Parameters
Returns
GetZDeflectionPara_umdN(double)
The axial tip deflection per unit axial force applied at
loadHeight_mm above the tip, µm/N:
∫ₐᴸ 1 / (E·A) dz. The edges of
GetBendingPara_umdN(double) apply.
public double GetZDeflectionPara_umdN(double loadHeight_mm)Parameters
loadHeight_mmdouble