corc.winding.Winding Class Reference

Public Member Functions
	__init__ (self, float tapeWidth, float gap, float tapeThickness, float solderThickness, int numTapesPerLayer, int numLayers, float pitch, float numTurns, float delta, float tapeResolution)
	solder_fractions (self, float stackThickness)
	tape_shift (self)
	cap_rotation (self)
int	s_partition_count (self)
int	n_phi (self, int layer_index, str kind)

Public Attributes
	tapeWidth = tapeWidth
	gap = gap
	numTapesPerLayer = numTapesPerLayer
int	numLayers = numLayers
	pitch = pitch
	numTurns = numTurns
	delta = delta
	tapeResolution = tapeResolution
float	omega = 1.0 / pitch
float	length = pitch * 2.0 * math.pi * numTurns
tuple	interlayer = (tapeThickness + solderThickness) * 0.001
list	layers = []

Constructor & Destructor Documentation

__init__()

corc.winding.Winding.__init__	(		self,
		float	tapeWidth,
		float	gap,
		float	tapeThickness,
		float	solderThickness,
		int	numTapesPerLayer,
		int	numLayers,
		float	pitch,
		float	numTurns,
		float	delta,
		float	tapeResolution )

Member Function Documentation

cap_rotation()

corc.winding.Winding.cap_rotation

(

self

)

The single in-plane rotation that maps every layer's partition
at s=0 to its partition at s=L. Raises if none exists (then the
caps cannot be periodic images and FEM mode must refuse).

n_phi()

int corc.winding.Winding.n_phi	(		self,
		int	layer_index,
		str	kind )

Single source of truth for angular interval counts (Grok #13).
kind is 'tape' or 'gap'. The count also guarantees each angular
slot spans <= pi/2 so cap circle arcs can always be chunked below
the built-in kernel's pi limit (matters for numTapesPerLayer=1,
where a single gap can span nearly 2 pi).

s_partition_count()

int corc.winding.Winding.s_partition_count

(

self

)

Number of s-intervals shared by all strips of one layer (and the
domain tube): from delta (degrees of winding per row, as today).

solder_fractions()

corc.winding.Winding.solder_fractions	(		self,
		float	stackThickness )

Real-solder fraction of each inter-layer annulus: the BELFEM
'density correction' for a deck that meshes those volumes as
solder while the tapes ride on the layer surfaces as thin shells.

stackThickness is the physical tape stack in um (the sum of the
BELFEM layers block), as opposed to tapeThickness, which is the
radial slot the winding schedule reserves per layer.

Convention: each layer's stack lies radially outward of its shell
surface -- the same one-slot-per-layer rule the layer radii above
are stacked by -- so the annulus between layers l and l+1 carries
exactly layer l's tapes, and the outermost stack extends into the
outer air volume, where there is no solder mass to correct.

A helical strip of arc width w covers w * L of cylinder surface
regardless of pitch, so per unit length the annulus holds
pi (r1^2 - r0^2) of meshed solder and n * w * t of real tape and
the cable length drops out. For bent centerlines this is the
straight-equivalent value: bending stretches tape and annulus by
the same local factor to first order.

Returns one fraction per annulus, i.e. per BELFEM volume 2..nL
(assembler ordering: 1 = inner, 2..nL = interlayer, nL+1 = outer).

tape_shift()

corc.winding.Winding.tape_shift

(

self

)

Number of tape positions every tape advances over the cable
length, when that is a whole number: q = numTurns * numTapesPerLayer.
With q whole the partition of EVERY layer at s=L coincides with its
partition at s=0 (the pattern is n-fold symmetric, and counter-wound
layers advance by -q, which is the same set), so the caps close with
zero rotation and tape k's far end is tape (k+q mod n)'s near end --
the periodic twist: with n = 3 and numTurns = 1/3 (or 4/3, ...)
sideset 4 continues into 5, 5 into 6, 6 into 4, and the inner layer
likewise. Returns None when q is not whole.

Member Data Documentation

delta

corc.winding.Winding.delta = delta

gap

corc.winding.Winding.gap = gap

interlayer

corc.winding.Winding.interlayer = (tapeThickness + solderThickness) * 0.001

layers

list corc.winding.Winding.layers = []

length

float corc.winding.Winding.length = pitch * 2.0 * math.pi * numTurns

numLayers

int corc.winding.Winding.numLayers = numLayers

numTapesPerLayer

corc.winding.Winding.numTapesPerLayer = numTapesPerLayer

numTurns

corc.winding.Winding.numTurns = numTurns

omega

float corc.winding.Winding.omega = 1.0 / pitch

pitch

corc.winding.Winding.pitch = pitch

tapeResolution

corc.winding.Winding.tapeResolution = tapeResolution

tapeWidth

corc.winding.Winding.tapeWidth = tapeWidth

---

The documentation for this class was generated from the following file:

• examples/corc_twolayer/python/corc/winding.py