LOCOSOxidation Namespace Reference

Functions
int	to_index (float x)
None	write_surface (level_set, str file_name)

Variables
int	USE_GPU = "gpu"
float	GRID_DELTA = 0.01
float	X_EXTENT = 1.0
float	Y_MIN = -1.0
float	Y_MAX = 2.0
float	PAD_OXIDE_THICKNESS = 0.03
float	MASK_THICKNESS = 0.05
float	MASK_EDGE = 0.0
float	ADVECTION_TIME = 0.1
float	TIME_STEP = 0.01
int	MASK_CONTACT_EPS = 1.e-6
list	bounds = [-X_EXTENT, X_EXTENT, Y_MIN, Y_MAX]
list	bcs
	si_interface = vls.Domain(bounds, bcs, GRID_DELTA)
	ambient_interface = vls.Domain(si_interface)
	si_initial = vls.Domain(si_interface)
	ambient_initial = vls.Domain(ambient_interface)
	mask_interface = vls.Domain(bounds, bcs, GRID_DELTA)
	mask_geom
	ox_params = vls.OxidationPresets.wet1000CDealGrove100()
	velocitySign
	maskTransferCoefficient
	maskConcentration
	maxIterations
	tolerance
	def_params = vls.OxidationPresets.oxideMechanics1000C(TIME_STEP)
	coupling_params = vls.OxidationCouplingParameters()
	relaxation
	mask_params = vls.OxidationPresets.siliconNitrideMask1000C()
list	diff_min = [to_index(-X_EXTENT), to_index(Y_MIN)]
list	diff_max = [to_index(X_EXTENT), to_index(Y_MAX)]
list	mask_min = [to_index(-X_EXTENT), to_index(PAD_OXIDE_THICKNESS) - 1]
list	mask_max = [to_index(MASK_EDGE), to_index(PAD_OXIDE_THICKNESS + MASK_THICKNESS) + 1]
	locos = vls.Oxidation(si_interface, ambient_interface, mask_interface)
float	elapsed = 0.0
float	time_eps = ADVECTION_TIME * 1.e-8
	dt = min(TIME_STEP, ADVECTION_TIME - elapsed)
	diffusion = locos.getDiffusionField()
	deformation = locos.getDeformationField()
	mask_bending = locos.getMaskBendingField()
list	open_pt = [0.5, GRID_DELTA, 0.]
list	masked_pt = [-0.5, GRID_DELTA, 0.]
list	normal_up = [0., 1., 0.]
	open_conc = diffusion.getConcentration(open_pt)
	masked_conc = diffusion.getConcentration(masked_pt)
	open_si_speed = abs(diffusion.getScalarVelocity(open_pt, 0, normal_up, 0))
	masked_si_speed = abs(diffusion.getScalarVelocity(masked_pt, 0, normal_up, 0))
tuple	suppression_ratio = (masked_si_speed / open_si_speed) if open_si_speed > 0. else 0.
	file
	newline
	writer = csv.writer(f)
list	coord = [i * GRID_DELTA, j * GRID_DELTA, 0.]
	vel = deformation.getVelocity(coord)
list	normal_dn = [0., -1., 0.]
dict	mask_pts
dict	vels
	mask_bottom_pressure = deformation.getPressure(mask_pts["bottom"][0])
dict	v = vels["bottom"]
dict	vc = vels["contact_node"]
	va
	vm
	ve
	conservation

Detailed Description

LOCOS (Local Oxidation of Silicon) example — ViennaLS low-level API.

Geometry (2-D cross-section):
    · Si substrate at y = 0
    · Pad SiO2 of thickness padOxideThickness grown by geometric advect
    · Si3N4 mask box covering x ∈ [−xExtent, maskEdge], sitting on pad oxide

This script uses the ViennaLS Oxidation solver directly (lsOxidation),
bypassing ViennaPS.  It mirrors LOCOSOxidation.cpp exactly.

Usage:
    python LOCOSOxidation.py

All lengths are in micrometers, time in hours, pressure in Pa.

Function Documentation

to_index()

int LOCOSOxidation.to_index

(

float

x

)

write_surface()

None LOCOSOxidation.write_surface	(		level_set,
		str	file_name )

Variable Documentation

ADVECTION_TIME

float LOCOSOxidation.ADVECTION_TIME = 0.1

ambient_initial

LOCOSOxidation.ambient_initial = vls.Domain(ambient_interface)

ambient_interface

LOCOSOxidation.ambient_interface = vls.Domain(si_interface)

bcs

list LOCOSOxidation.bcs

Initial value:

=  [vls.BoundaryConditionEnum.REFLECTIVE_BOUNDARY,
          vls.BoundaryConditionEnum.INFINITE_BOUNDARY]

bounds

list LOCOSOxidation.bounds = [-X_EXTENT, X_EXTENT, Y_MIN, Y_MAX]

conservation

LOCOSOxidation.conservation

Initial value:

=  vls.computeLOCOSOpenWindowConservation(
    si_initial, si_interface,
    ambient_initial, ambient_interface,
    0.1, 0.9,
    to_index(Y_MIN), to_index(Y_MAX),
    ox_params.expansionCoefficient,
)

coord

list LOCOSOxidation.coord = [i * GRID_DELTA, j * GRID_DELTA, 0.]

coupling_params

LOCOSOxidation.coupling_params = vls.OxidationCouplingParameters()

def_params

LOCOSOxidation.def_params = vls.OxidationPresets.oxideMechanics1000C(TIME_STEP)

deformation

LOCOSOxidation.deformation = locos.getDeformationField()

diff_max

list LOCOSOxidation.diff_max = [to_index(X_EXTENT), to_index(Y_MAX)]

diff_min

list LOCOSOxidation.diff_min = [to_index(-X_EXTENT), to_index(Y_MIN)]

diffusion

LOCOSOxidation.diffusion = locos.getDiffusionField()

dt

LOCOSOxidation.dt = min(TIME_STEP, ADVECTION_TIME - elapsed)

elapsed

float LOCOSOxidation.elapsed = 0.0

file

LOCOSOxidation.file

GRID_DELTA

float LOCOSOxidation.GRID_DELTA = 0.01

locos

LOCOSOxidation.locos = vls.Oxidation(si_interface, ambient_interface, mask_interface)

mask_bending

LOCOSOxidation.mask_bending = locos.getMaskBendingField()

mask_bottom_pressure

LOCOSOxidation.mask_bottom_pressure = deformation.getPressure(mask_pts["bottom"][0])

MASK_CONTACT_EPS

int LOCOSOxidation.MASK_CONTACT_EPS = 1.e-6

MASK_EDGE

float LOCOSOxidation.MASK_EDGE = 0.0

mask_geom

LOCOSOxidation.mask_geom

Initial value:

=  vls.MakeGeometry(
    mask_interface,
    vls.Box(
        [-X_EXTENT,  PAD_OXIDE_THICKNESS - MASK_CONTACT_EPS],
        [MASK_EDGE,  PAD_OXIDE_THICKNESS + MASK_THICKNESS],
    ),
)

mask_interface

LOCOSOxidation.mask_interface = vls.Domain(bounds, bcs, GRID_DELTA)

mask_max

list LOCOSOxidation.mask_max = [to_index(MASK_EDGE), to_index(PAD_OXIDE_THICKNESS + MASK_THICKNESS) + 1]

mask_min

list LOCOSOxidation.mask_min = [to_index(-X_EXTENT), to_index(PAD_OXIDE_THICKNESS) - 1]

mask_params

LOCOSOxidation.mask_params = vls.OxidationPresets.siliconNitrideMask1000C()

mask_pts

dict LOCOSOxidation.mask_pts

Initial value:

=  {
    "bottom":       ([-0.5, PAD_OXIDE_THICKNESS,                         0.], normal_dn),
    "top":          ([-0.5, PAD_OXIDE_THICKNESS + MASK_THICKNESS,        0.], normal_up),
    "contact_node": ([-GRID_DELTA, PAD_OXIDE_THICKNESS,                  0.], normal_dn),
    "anchor":       ([-X_EXTENT + GRID_DELTA,
                      PAD_OXIDE_THICKNESS + MASK_THICKNESS * 0.5,        0.], normal_up),
    "mid":          ([-0.5, PAD_OXIDE_THICKNESS + MASK_THICKNESS * 0.5,  0.], normal_up),
    "edge":         ([-GRID_DELTA, PAD_OXIDE_THICKNESS + MASK_THICKNESS * 0.5, 0.], normal_up),
}

MASK_THICKNESS

float LOCOSOxidation.MASK_THICKNESS = 0.05

maskConcentration

LOCOSOxidation.maskConcentration

masked_conc

LOCOSOxidation.masked_conc = diffusion.getConcentration(masked_pt)

masked_pt

list LOCOSOxidation.masked_pt = [-0.5, GRID_DELTA, 0.]

masked_si_speed

LOCOSOxidation.masked_si_speed = abs(diffusion.getScalarVelocity(masked_pt, 0, normal_up, 0))

maskTransferCoefficient

LOCOSOxidation.maskTransferCoefficient

maxIterations

LOCOSOxidation.maxIterations

newline

LOCOSOxidation.newline

normal_dn

list LOCOSOxidation.normal_dn = [0., -1., 0.]

normal_up

list LOCOSOxidation.normal_up = [0., 1., 0.]

open_conc

LOCOSOxidation.open_conc = diffusion.getConcentration(open_pt)

open_pt

list LOCOSOxidation.open_pt = [0.5, GRID_DELTA, 0.]

open_si_speed

LOCOSOxidation.open_si_speed = abs(diffusion.getScalarVelocity(open_pt, 0, normal_up, 0))

ox_params

LOCOSOxidation.ox_params = vls.OxidationPresets.wet1000CDealGrove100()

PAD_OXIDE_THICKNESS

float LOCOSOxidation.PAD_OXIDE_THICKNESS = 0.03

relaxation

LOCOSOxidation.relaxation

si_initial

LOCOSOxidation.si_initial = vls.Domain(si_interface)

si_interface

LOCOSOxidation.si_interface = vls.Domain(bounds, bcs, GRID_DELTA)

suppression_ratio

tuple LOCOSOxidation.suppression_ratio = (masked_si_speed / open_si_speed) if open_si_speed > 0. else 0.

time_eps

float LOCOSOxidation.time_eps = ADVECTION_TIME * 1.e-8

TIME_STEP

float LOCOSOxidation.TIME_STEP = 0.01

tolerance

LOCOSOxidation.tolerance

USE_GPU

int LOCOSOxidation.USE_GPU = "gpu"

v

dict LOCOSOxidation.v = vels["bottom"]

va

LOCOSOxidation.va

vc

dict LOCOSOxidation.vc = vels["contact_node"]

ve

LOCOSOxidation.ve

vel

LOCOSOxidation.vel = deformation.getVelocity(coord)

velocitySign

LOCOSOxidation.velocitySign

vels

dict LOCOSOxidation.vels

Initial value:

=  {name: mask_bending.getVectorVelocity(pt, 0, n, 0)
        for name, (pt, n) in mask_pts.items()}

vm

LOCOSOxidation.vm

writer

LOCOSOxidation.writer = csv.writer(f)

X_EXTENT

float LOCOSOxidation.X_EXTENT = 1.0

Y_MAX

float LOCOSOxidation.Y_MAX = 2.0

Y_MIN

float LOCOSOxidation.Y_MIN = -1.0