devsim 2.10.0__cp39-abi3-win_amd64.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- devsim/__init__.py +17 -0
- devsim/devsim_py3.pyd +0 -0
- devsim/python_packages/Klaassen.py +336 -0
- devsim/python_packages/__init__.py +0 -0
- devsim/python_packages/fermi_physics.py +31 -0
- devsim/python_packages/model_create.py +262 -0
- devsim/python_packages/mos_physics.py +170 -0
- devsim/python_packages/pythonmesh.py +131 -0
- devsim/python_packages/ramp.py +101 -0
- devsim/python_packages/simple_dd.py +75 -0
- devsim/python_packages/simple_physics.py +463 -0
- devsim/umfpack/umfpack_lgpl.dll +0 -0
- devsim/umfpack/umfpack_loader.py +517 -0
- devsim/umfpack/umfshim.py +116 -0
- devsim-2.10.0.data/data/devsim_data/BUILD.md +94 -0
- devsim-2.10.0.data/data/devsim_data/CHANGES.md +773 -0
- devsim-2.10.0.data/data/devsim_data/CITATION.md +23 -0
- devsim-2.10.0.data/data/devsim_data/CODE_OF_CONDUCT.md +74 -0
- devsim-2.10.0.data/data/devsim_data/CONTRIBUTING.md +43 -0
- devsim-2.10.0.data/data/devsim_data/HOWTO.md +27 -0
- devsim-2.10.0.data/data/devsim_data/INSTALL.md +65 -0
- devsim-2.10.0.data/data/devsim_data/README.md +97 -0
- devsim-2.10.0.data/data/devsim_data/TEST.md +13 -0
- devsim-2.10.0.data/data/devsim_data/doc/devsim.pdf +0 -0
- devsim-2.10.0.data/data/devsim_data/doc/symdiff.pdf +0 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/Ve0.jpg +0 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/Ve0_3d.jpg +0 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/Ve7.jpg +0 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/Ve7_3d.jpg +0 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/bioapp1_2d.py +85 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/bioapp1_3d.py +85 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/bioapp1_common.py +399 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/disk_2d.geo +62 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/disk_2d.msh +65606 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/disk_3d.geo +183 -0
- devsim-2.10.0.data/data/devsim_data/examples/bioapp1/disk_3d.msh +25808 -0
- devsim-2.10.0.data/data/devsim_data/examples/capacitance/cap.lay +1587 -0
- devsim-2.10.0.data/data/devsim_data/examples/capacitance/cap1d.py +155 -0
- devsim-2.10.0.data/data/devsim_data/examples/capacitance/cap2d.py +200 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/3dblock.geo +48 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_1d.py +94 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_1d_custom.py +159 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_2d.py +68 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_common.py +253 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_current.lay +3271 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_density.lay +3271 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/diode_potential.lay +3272 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode2d.msh +1477 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode2d.py +55 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode3d.msh +8557 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode3d.py +74 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode3d_equil.py +43 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/gmsh_diode3d_float128.py +85 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/laux2d.py +43 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/laux3d.py +54 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/laux_common.py +503 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/pythonmesh3d.py +61 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/ssac_diode.py +57 -0
- devsim-2.10.0.data/data/devsim_data/examples/diode/tran_diode.py +63 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/gmsh_mos2d.geo +160 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/gmsh_mos2d.msh +8599 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/gmsh_mos2d.py +96 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/gmsh_mos2d_create.py +174 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/gmsh_mos2d_kla.py +162 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/logElectrons.lay +1327 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/pythonmesh2d.py +100 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/test.lay +3385 -0
- devsim-2.10.0.data/data/devsim_data/examples/mobility/times.txt +34 -0
- devsim-2.10.0.data/data/devsim_data/examples/plotting/visualization.ipynb +160 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/arrhenius.py +24 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/deftest.py +48 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/modellist1.py +9 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/models1.py +41 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/ordered.py +9 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/parsetest.py +107 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/remove1.py +8 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/subexpression1.py +10 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/table.py +7 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/undefined1.py +10 -0
- devsim-2.10.0.data/data/devsim_data/examples/symdiff/utf8.py +10 -0
- devsim-2.10.0.data/data/devsim_data/examples/vectorpotential/twowire.geo +34 -0
- devsim-2.10.0.data/data/devsim_data/examples/vectorpotential/twowire.lay +1469 -0
- devsim-2.10.0.data/data/devsim_data/examples/vectorpotential/twowire.msh +13596 -0
- devsim-2.10.0.data/data/devsim_data/examples/vectorpotential/twowire.py +177 -0
- devsim-2.10.0.data/data/devsim_data/setup.cfg +23 -0
- devsim-2.10.0.data/data/devsim_data/setup.py +58 -0
- devsim-2.10.0.data/data/devsim_data/testing/3dtetmesh.msh +281 -0
- devsim-2.10.0.data/data/devsim_data/testing/CMakeLists.txt +175 -0
- devsim-2.10.0.data/data/devsim_data/testing/Fermi1.py +59 -0
- devsim-2.10.0.data/data/devsim_data/testing/Fermi1_float128.py +18 -0
- devsim-2.10.0.data/data/devsim_data/testing/GaussFermi.py +38 -0
- devsim-2.10.0.data/data/devsim_data/testing/GaussFermi_float128.py +18 -0
- devsim-2.10.0.data/data/devsim_data/testing/cap2.py +439 -0
- devsim-2.10.0.data/data/devsim_data/testing/cap_mesh.py +33 -0
- devsim-2.10.0.data/data/devsim_data/testing/circ1.py +79 -0
- devsim-2.10.0.data/data/devsim_data/testing/circ2.py +79 -0
- devsim-2.10.0.data/data/devsim_data/testing/circ3.py +18 -0
- devsim-2.10.0.data/data/devsim_data/testing/circ4.py +105 -0
- devsim-2.10.0.data/data/devsim_data/testing/dio2_element_2d.py +136 -0
- devsim-2.10.0.data/data/devsim_data/testing/dio2_element_physics.py +302 -0
- devsim-2.10.0.data/data/devsim_data/testing/equation1.py +68 -0
- devsim-2.10.0.data/data/devsim_data/testing/erf1.py +52 -0
- devsim-2.10.0.data/data/devsim_data/testing/erf2.py +34 -0
- devsim-2.10.0.data/data/devsim_data/testing/fpetest1.py +21 -0
- devsim-2.10.0.data/data/devsim_data/testing/fpetest2.py +25 -0
- devsim-2.10.0.data/data/devsim_data/testing/gmsh_mos3d.geo +272 -0
- devsim-2.10.0.data/data/devsim_data/testing/info.py +11 -0
- devsim-2.10.0.data/data/devsim_data/testing/kahan.py +24 -0
- devsim-2.10.0.data/data/devsim_data/testing/kahan_float128.py +18 -0
- devsim-2.10.0.data/data/devsim_data/testing/laux1.py +232 -0
- devsim-2.10.0.data/data/devsim_data/testing/mctest.mc +30 -0
- devsim-2.10.0.data/data/devsim_data/testing/mctest_user.mc +33 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh1.msh +52 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh1.py +121 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh2.msh +70 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh2.py +210 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh2d.py +105 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh3.py +8 -0
- devsim-2.10.0.data/data/devsim_data/testing/mesh4.py +8 -0
- devsim-2.10.0.data/data/devsim_data/testing/mos_2d.py +111 -0
- devsim-2.10.0.data/data/devsim_data/testing/mos_2d_create.py +207 -0
- devsim-2.10.0.data/data/devsim_data/testing/mos_2d_restart.py +69 -0
- devsim-2.10.0.data/data/devsim_data/testing/mos_2d_restart2.py +24 -0
- devsim-2.10.0.data/data/devsim_data/testing/noise_res.py +51 -0
- devsim-2.10.0.data/data/devsim_data/testing/noise_res_2d.py +101 -0
- devsim-2.10.0.data/data/devsim_data/testing/ptest1.py +53 -0
- devsim-2.10.0.data/data/devsim_data/testing/ptest2.py +110 -0
- devsim-2.10.0.data/data/devsim_data/testing/pythonmesh1d.py +202 -0
- devsim-2.10.0.data/data/devsim_data/testing/res1.py +65 -0
- devsim-2.10.0.data/data/devsim_data/testing/res2.py +65 -0
- devsim-2.10.0.data/data/devsim_data/testing/res3.py +59 -0
- devsim-2.10.0.data/data/devsim_data/testing/rundifftest.py +62 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_cap.py +145 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_cap_2d_edge.py +199 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_cap_2d_element.py +214 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_cap_3d_edge.py +148 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_cap_3d_element.py +167 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_circ.py +18 -0
- devsim-2.10.0.data/data/devsim_data/testing/ssac_res.py +30 -0
- devsim-2.10.0.data/data/devsim_data/testing/symdiff1.py +54 -0
- devsim-2.10.0.data/data/devsim_data/testing/test_common.py +435 -0
- devsim-2.10.0.data/data/devsim_data/testing/testfunc.py +65 -0
- devsim-2.10.0.data/data/devsim_data/testing/testfunc_extended.py +8 -0
- devsim-2.10.0.data/data/devsim_data/testing/transient_circ.py +67 -0
- devsim-2.10.0.data/data/devsim_data/testing/transient_circ2.py +67 -0
- devsim-2.10.0.data/data/devsim_data/testing/transient_circ3.py +125 -0
- devsim-2.10.0.data/data/devsim_data/testing/transient_rc.py +157 -0
- devsim-2.10.0.data/data/devsim_data/testing/trimesh1.msh +47 -0
- devsim-2.10.0.data/data/devsim_data/testing/trimesh1.py +114 -0
- devsim-2.10.0.data/data/devsim_data/testing/trimesh2.py +114 -0
- devsim-2.10.0.data/data/devsim_data/testing/utf8_2.py +126 -0
- devsim-2.10.0.dist-info/METADATA +121 -0
- devsim-2.10.0.dist-info/RECORD +157 -0
- devsim-2.10.0.dist-info/WHEEL +5 -0
- devsim-2.10.0.dist-info/licenses/LICENSE +202 -0
- devsim-2.10.0.dist-info/licenses/NOTICE +241 -0
- devsim-2.10.0.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,503 @@
|
|
|
1
|
+
# Copyright 2013 DEVSIM LLC
|
|
2
|
+
#
|
|
3
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
4
|
+
|
|
5
|
+
# The purpose is to verify our triangle element field calculation.
|
|
6
|
+
# It is based on Laux's weighting scheme
|
|
7
|
+
# @article{Laux:1985,
|
|
8
|
+
# author = {Laux, Steven E. and Byrnes, Robert G.},
|
|
9
|
+
# title = {Semiconductor device simulation using generalized mobility models},
|
|
10
|
+
# journal = {IBM J. Res. Dev.},
|
|
11
|
+
# issue_date = {May 1985},
|
|
12
|
+
# volume = {29},
|
|
13
|
+
# number = {3},
|
|
14
|
+
# month = may,
|
|
15
|
+
# year = {1985},
|
|
16
|
+
# issn = {0018-8646},
|
|
17
|
+
# pages = {289--301},
|
|
18
|
+
# numpages = {13},
|
|
19
|
+
# url = {http://dx.doi.org/10.1147/rd.293.0289},
|
|
20
|
+
# doi = {10.1147/rd.293.0289},
|
|
21
|
+
# acmid = {1012099},
|
|
22
|
+
# publisher = {IBM Corp.},
|
|
23
|
+
# address = {Riverton, NJ, USA},
|
|
24
|
+
# }
|
|
25
|
+
|
|
26
|
+
|
|
27
|
+
import sys
|
|
28
|
+
|
|
29
|
+
try:
|
|
30
|
+
import numpy
|
|
31
|
+
except ImportError:
|
|
32
|
+
print(
|
|
33
|
+
"numpy is not available with your installation and is required for this program."
|
|
34
|
+
)
|
|
35
|
+
sys.exit(1)
|
|
36
|
+
|
|
37
|
+
|
|
38
|
+
from devsim import (
|
|
39
|
+
element_from_edge_model,
|
|
40
|
+
element_from_node_model,
|
|
41
|
+
element_model,
|
|
42
|
+
element_pair_from_edge_model,
|
|
43
|
+
get_element_model_values,
|
|
44
|
+
)
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
dim = None
|
|
48
|
+
nee = None
|
|
49
|
+
nen = None
|
|
50
|
+
directions = ("x", "y", "z")
|
|
51
|
+
|
|
52
|
+
|
|
53
|
+
def SetDimension(dimension):
|
|
54
|
+
global dim
|
|
55
|
+
global nee
|
|
56
|
+
global nen
|
|
57
|
+
if dimension == 2:
|
|
58
|
+
dim = 2 # dimension
|
|
59
|
+
nee = 3 # number of edges per element
|
|
60
|
+
nen = 3 # number of nodes per element
|
|
61
|
+
elif dimension == 3:
|
|
62
|
+
dim = 3
|
|
63
|
+
nee = 6
|
|
64
|
+
nen = 4
|
|
65
|
+
|
|
66
|
+
|
|
67
|
+
# nen edges make up the dense matrix calculation for 1 node
|
|
68
|
+
# the element corresponds to 1 of n tetrahedron
|
|
69
|
+
# node indexes are the element edge quantities
|
|
70
|
+
def GetElementData(element_index, node_indexes):
|
|
71
|
+
element_data = {}
|
|
72
|
+
nodes = []
|
|
73
|
+
|
|
74
|
+
# get nodes for each element edge 0, 1, 2, 3
|
|
75
|
+
edge_node_list = []
|
|
76
|
+
for j in range(nee):
|
|
77
|
+
index = nee * element_index + j
|
|
78
|
+
enodes = []
|
|
79
|
+
for i in node_indexes:
|
|
80
|
+
enodes.append(i[index])
|
|
81
|
+
edge_node_list.append(enodes)
|
|
82
|
+
element_data["edge_node_list"] = edge_node_list
|
|
83
|
+
|
|
84
|
+
# get the all of the node indexes on the element
|
|
85
|
+
# also available using get_element_node_list
|
|
86
|
+
nodes = sorted(edge_node_list[0])
|
|
87
|
+
element_data["node_indexes"] = nodes
|
|
88
|
+
|
|
89
|
+
vmap = {}
|
|
90
|
+
for i in range(nen):
|
|
91
|
+
vmap[nodes[i]] = i
|
|
92
|
+
element_data["node_index_positions"] = vmap
|
|
93
|
+
|
|
94
|
+
# n0 and n1 indexes for each element edge head and tail
|
|
95
|
+
node_to_edge_indexes = []
|
|
96
|
+
n0_indexes = node_indexes[0]
|
|
97
|
+
n1_indexes = node_indexes[1]
|
|
98
|
+
for ni in nodes:
|
|
99
|
+
edge_indexes = []
|
|
100
|
+
for j in range(nee):
|
|
101
|
+
ei = nee * element_index + j
|
|
102
|
+
if (n0_indexes[ei] == ni) or (n1_indexes[ei] == ni):
|
|
103
|
+
edge_indexes.append(j)
|
|
104
|
+
node_to_edge_indexes.append(edge_indexes)
|
|
105
|
+
# how each node index connects to which element edge
|
|
106
|
+
element_data["node_to_edge_indexes"] = node_to_edge_indexes
|
|
107
|
+
|
|
108
|
+
# store the element index
|
|
109
|
+
element_data["element_index"] = element_index
|
|
110
|
+
return element_data
|
|
111
|
+
|
|
112
|
+
|
|
113
|
+
def GetNodeMatrices(element_data, unit_vectors):
|
|
114
|
+
# create the matrix associated with a given node
|
|
115
|
+
matrices = []
|
|
116
|
+
ei = element_data["element_index"]
|
|
117
|
+
for i in range(nen):
|
|
118
|
+
edge_indexes = element_data["node_to_edge_indexes"][i]
|
|
119
|
+
M = numpy.zeros((dim, dim))
|
|
120
|
+
for j in range(dim):
|
|
121
|
+
edge_index = nee * ei + edge_indexes[j]
|
|
122
|
+
for k in range(dim):
|
|
123
|
+
M[j][k] = unit_vectors[k][edge_index]
|
|
124
|
+
matrices.append(M)
|
|
125
|
+
return matrices
|
|
126
|
+
|
|
127
|
+
|
|
128
|
+
def CalculateEField(element_data, scalar_efield):
|
|
129
|
+
# calculate the vector field with respect to each scalar edge quantity
|
|
130
|
+
# calculated for each of the nen nodes on the element
|
|
131
|
+
vector_efields = []
|
|
132
|
+
ei = element_data["element_index"]
|
|
133
|
+
matrices = element_data["matrices"]
|
|
134
|
+
for i in range(nen):
|
|
135
|
+
edge_indexes = element_data["node_to_edge_indexes"][i]
|
|
136
|
+
B = numpy.zeros((dim, 1))
|
|
137
|
+
for j in range(dim):
|
|
138
|
+
edge_index = nee * ei + edge_indexes[j]
|
|
139
|
+
B[j] = scalar_efield[edge_index]
|
|
140
|
+
ans = numpy.linalg.solve(matrices[i], B)
|
|
141
|
+
vector_efields.append(ans)
|
|
142
|
+
return vector_efields
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
def CalculateEFieldDerivatives(element_data, scalar_efield_derivatives):
|
|
146
|
+
# handle the case for each node derivative
|
|
147
|
+
# scalar fields are w.r.t. to n0 and n1 on each edge
|
|
148
|
+
vector_efield_derivatives = []
|
|
149
|
+
ei = element_data["element_index"]
|
|
150
|
+
matrices = element_data["matrices"]
|
|
151
|
+
# These are the derivatives for all of the nodes of the whole element
|
|
152
|
+
node_indexes = element_data["node_indexes"]
|
|
153
|
+
for i in range(nen):
|
|
154
|
+
edge_indexes = element_data["node_to_edge_indexes"][i]
|
|
155
|
+
B = numpy.zeros((dim, nen))
|
|
156
|
+
for j in range(dim):
|
|
157
|
+
edge_index = edge_indexes[j]
|
|
158
|
+
input_edge_index = nee * ei + edge_index
|
|
159
|
+
edge_node_list = element_data["edge_node_list"][edge_index]
|
|
160
|
+
# these are the derivative nodes corresponding
|
|
161
|
+
for k in range(nen):
|
|
162
|
+
# this is the node we are taking the derivative with respect to
|
|
163
|
+
# it is over the entire element
|
|
164
|
+
nk = node_indexes[k]
|
|
165
|
+
# are we in the head or tail node
|
|
166
|
+
val = 0.0
|
|
167
|
+
if nk == edge_node_list[0]:
|
|
168
|
+
val = scalar_efield_derivatives[0][input_edge_index]
|
|
169
|
+
elif nk == edge_node_list[1]:
|
|
170
|
+
val = scalar_efield_derivatives[1][input_edge_index]
|
|
171
|
+
# each column corresponds to a different derivative node
|
|
172
|
+
B[j][k] = val
|
|
173
|
+
ans = numpy.linalg.solve(matrices[i], B)
|
|
174
|
+
vector_efield_derivatives.append(ans)
|
|
175
|
+
return vector_efield_derivatives
|
|
176
|
+
|
|
177
|
+
|
|
178
|
+
def CalculateFinalValuesPairs(element_data, vector_efields, output0, output1):
|
|
179
|
+
ei = element_data["element_index"]
|
|
180
|
+
_node_indexes = element_data["node_indexes"]
|
|
181
|
+
edge_node_list = element_data["edge_node_list"]
|
|
182
|
+
node_index_positions = element_data["node_index_positions"]
|
|
183
|
+
|
|
184
|
+
outputs = [output0, output1]
|
|
185
|
+
|
|
186
|
+
for edge_index in range(nee):
|
|
187
|
+
enodes = edge_node_list[edge_index]
|
|
188
|
+
output_edge_index = nee * ei + edge_index
|
|
189
|
+
for i, ii in enumerate(enodes[0:2]):
|
|
190
|
+
# make sure node indexes are in proper range
|
|
191
|
+
val = numpy.transpose(vector_efields[node_index_positions[ii]][:, 0])
|
|
192
|
+
outputs[i][output_edge_index, 0:dim] = val
|
|
193
|
+
|
|
194
|
+
|
|
195
|
+
def CalculateFinalDerivativesPairs(
|
|
196
|
+
element_data, vector_efield_derivatives, output0, output1
|
|
197
|
+
):
|
|
198
|
+
ei = element_data["element_index"]
|
|
199
|
+
_node_indexes = element_data["node_indexes"]
|
|
200
|
+
edge_node_list = element_data["edge_node_list"]
|
|
201
|
+
node_index_positions = element_data["node_index_positions"]
|
|
202
|
+
|
|
203
|
+
outputs = [output0, output1]
|
|
204
|
+
|
|
205
|
+
for edge_index in range(nee): # for each element edge
|
|
206
|
+
enodes = edge_node_list[edge_index]
|
|
207
|
+
output_edge_index = nee * ei + edge_index
|
|
208
|
+
for i, ii in enumerate(enodes[0:2]):
|
|
209
|
+
for k, kk in enumerate(enodes): # for the derivative nodes
|
|
210
|
+
val = numpy.transpose(
|
|
211
|
+
vector_efield_derivatives[node_index_positions[ii]][
|
|
212
|
+
:, node_index_positions[kk]
|
|
213
|
+
]
|
|
214
|
+
)
|
|
215
|
+
row_stride = slice(dim * (k + 1), dim * (k + 2))
|
|
216
|
+
outputs[i][output_edge_index, row_stride] = val
|
|
217
|
+
|
|
218
|
+
|
|
219
|
+
# for i in range(nen):
|
|
220
|
+
# edge_indexes = node_to_edge_indexes_map[i]
|
|
221
|
+
# for j in range(dim):
|
|
222
|
+
# edge_index = edge_indexes[j]
|
|
223
|
+
# output_edge_index = nee * ei + edge_index
|
|
224
|
+
# for k in range(nen):
|
|
225
|
+
# # this are the derivatives corresponding to the ordered list of nodes on the entire element
|
|
226
|
+
# nk = node_indexes[k]
|
|
227
|
+
# #val = 0.5 * numpy.transpose(vector_efield_derivatives[i][:][k])
|
|
228
|
+
# val = 0.5 * numpy.transpose(vector_efield_derivatives[i][:,k])
|
|
229
|
+
# for kk in range(nen):
|
|
230
|
+
# nkk = edge_node_list[edge_index][kk]
|
|
231
|
+
# if nk == nkk:
|
|
232
|
+
# row_stride = slice(dim*(kk+1),dim*(kk+2))
|
|
233
|
+
# #print row_stride
|
|
234
|
+
# output[output_edge_index, row_stride] += val
|
|
235
|
+
|
|
236
|
+
|
|
237
|
+
def CalculateFinalValues3D(element_data, vector_efields, output):
|
|
238
|
+
# this is the weighted value from each node on the edge
|
|
239
|
+
ei = element_data["element_index"]
|
|
240
|
+
# node_indexes = element_data['node_indexes']
|
|
241
|
+
# edge_node_list = element_data['edge_node_list']
|
|
242
|
+
node_to_edge_indexes_map = element_data["node_to_edge_indexes"]
|
|
243
|
+
for i in range(nen):
|
|
244
|
+
edge_indexes = node_to_edge_indexes_map[i]
|
|
245
|
+
# print len(edge_indexes)
|
|
246
|
+
# raise RuntimeError("STOP")
|
|
247
|
+
val = 0.5 * numpy.transpose(vector_efields[i][:, 0])
|
|
248
|
+
for j in range(dim):
|
|
249
|
+
edge_index = edge_indexes[j]
|
|
250
|
+
# if (abs(edge_index) > 5):
|
|
251
|
+
# raise RuntimeError("PROBLEM")
|
|
252
|
+
output_edge_index = nee * ei + edge_index
|
|
253
|
+
output[output_edge_index, 0:dim] += val
|
|
254
|
+
|
|
255
|
+
|
|
256
|
+
def CalculateFinalDerivatives3D(element_data, vector_efield_derivatives, output):
|
|
257
|
+
# this is the weighted value from each node on the edge
|
|
258
|
+
# now for the derivatives
|
|
259
|
+
ei = element_data["element_index"]
|
|
260
|
+
node_indexes = element_data["node_indexes"]
|
|
261
|
+
edge_node_list = element_data["edge_node_list"]
|
|
262
|
+
node_to_edge_indexes_map = element_data["node_to_edge_indexes"]
|
|
263
|
+
for i in range(nen):
|
|
264
|
+
edge_indexes = node_to_edge_indexes_map[i]
|
|
265
|
+
for j in range(dim):
|
|
266
|
+
edge_index = edge_indexes[j]
|
|
267
|
+
output_edge_index = nee * ei + edge_index
|
|
268
|
+
for k in range(nen):
|
|
269
|
+
# this are the derivatives corresponding to the ordered list of nodes on the entire element
|
|
270
|
+
nk = node_indexes[k]
|
|
271
|
+
# val = 0.5 * numpy.transpose(vector_efield_derivatives[i][:][k])
|
|
272
|
+
val = 0.5 * numpy.transpose(vector_efield_derivatives[i][:, k])
|
|
273
|
+
for kk in range(nen):
|
|
274
|
+
nkk = edge_node_list[edge_index][kk]
|
|
275
|
+
if nk == nkk:
|
|
276
|
+
row_stride = slice(dim * (kk + 1), dim * (kk + 2))
|
|
277
|
+
# print row_stride
|
|
278
|
+
output[output_edge_index, row_stride] += val
|
|
279
|
+
|
|
280
|
+
|
|
281
|
+
def CalculateFinalValues2D(element_data, vector_efields, ecouple, output):
|
|
282
|
+
ei = element_data["element_index"]
|
|
283
|
+
# this is special weighting based on edge away from edge of interest
|
|
284
|
+
wts = numpy.zeros((nee,)) # this handles the weights summed into our edge
|
|
285
|
+
outs = numpy.zeros((nee, dim))
|
|
286
|
+
# iterate over our element nodes
|
|
287
|
+
node_to_edge_indexes = element_data["node_to_edge_indexes"]
|
|
288
|
+
for i in range(nen):
|
|
289
|
+
edge_indexes = node_to_edge_indexes[i]
|
|
290
|
+
for j in edge_indexes:
|
|
291
|
+
for k in edge_indexes:
|
|
292
|
+
if j == k:
|
|
293
|
+
continue
|
|
294
|
+
wt = ecouple[nee * ei + k]
|
|
295
|
+
wts[j] += wt
|
|
296
|
+
outs[j] += wt * vector_efields[i][:, 0]
|
|
297
|
+
for i in range(nee):
|
|
298
|
+
outs[i] /= wts[i]
|
|
299
|
+
output[nee * ei + i, 0:dim] = numpy.transpose(outs[i])
|
|
300
|
+
|
|
301
|
+
|
|
302
|
+
def CalculateFinalDerivatives2D(
|
|
303
|
+
element_data, vector_efield_derivatives, ecouple, output
|
|
304
|
+
):
|
|
305
|
+
ei = element_data["element_index"]
|
|
306
|
+
# this is special weighting based on edge away from edge of interest
|
|
307
|
+
wts = numpy.zeros((nee,)) # this handles the weights summed into our edge
|
|
308
|
+
outs = numpy.zeros((nee, nen * dim))
|
|
309
|
+
# iterate over our element nodes
|
|
310
|
+
node_indexes = element_data["node_indexes"]
|
|
311
|
+
node_to_edge_indexes = element_data["node_to_edge_indexes"]
|
|
312
|
+
edge_node_list = element_data["edge_node_list"]
|
|
313
|
+
for i in range(nen):
|
|
314
|
+
edge_indexes = node_to_edge_indexes[i]
|
|
315
|
+
for j in edge_indexes:
|
|
316
|
+
for k in edge_indexes:
|
|
317
|
+
if j == k:
|
|
318
|
+
continue
|
|
319
|
+
wt = ecouple[nee * ei + k]
|
|
320
|
+
wts[j] += wt
|
|
321
|
+
for l in range(nen): # noqa: E741
|
|
322
|
+
row_stride = slice(dim * l, dim * (l + 1))
|
|
323
|
+
outs[j, row_stride] += wt * vector_efield_derivatives[i][:, l]
|
|
324
|
+
# outs[j,] += wt * vector_efields[i][:,0]
|
|
325
|
+
# val = 0.5 * numpy.transpose(vector_efield_derivatives[i][:,k])
|
|
326
|
+
for i in range(nee):
|
|
327
|
+
outs[i] /= wts[i]
|
|
328
|
+
for k in range(nen):
|
|
329
|
+
nk = node_indexes[k]
|
|
330
|
+
for kk in range(nen):
|
|
331
|
+
nkk = edge_node_list[i][kk]
|
|
332
|
+
if nk == nkk:
|
|
333
|
+
row_stride1 = slice(dim * (kk + 1), dim * (kk + 2))
|
|
334
|
+
row_stride2 = slice(dim * (k), dim * (k + 1))
|
|
335
|
+
# print row_stride1
|
|
336
|
+
# print row_stride2
|
|
337
|
+
output[nee * ei + i, row_stride1] = numpy.transpose(
|
|
338
|
+
outs[i, row_stride2]
|
|
339
|
+
)
|
|
340
|
+
break
|
|
341
|
+
|
|
342
|
+
|
|
343
|
+
def GetScalarField(device, region, name, mname):
|
|
344
|
+
element_model(device=device, region=region, name=name, equation=mname)
|
|
345
|
+
return numpy.array(
|
|
346
|
+
get_element_model_values(device=device, region=region, name=name)
|
|
347
|
+
)
|
|
348
|
+
|
|
349
|
+
|
|
350
|
+
def GetScalarFieldDerivatives(device, region, name, mname, vname):
|
|
351
|
+
ret = []
|
|
352
|
+
for i in range(2):
|
|
353
|
+
oname = name + str(i)
|
|
354
|
+
iname = "%s:%s@n%d" % (mname, vname, i)
|
|
355
|
+
element_model(device=device, region=region, name=oname, equation=iname)
|
|
356
|
+
ret.append(get_element_model_values(device=device, region=region, name=oname))
|
|
357
|
+
return ret
|
|
358
|
+
|
|
359
|
+
|
|
360
|
+
def GetNodeIndexes(device, region):
|
|
361
|
+
ret = []
|
|
362
|
+
element_from_node_model(node_model="node_index", device=device, region=region)
|
|
363
|
+
for i in range(nen):
|
|
364
|
+
tmp = get_element_model_values(
|
|
365
|
+
device=device, region=region, name="node_index@en%d" % i
|
|
366
|
+
)
|
|
367
|
+
tmp = [int(x) for x in tmp]
|
|
368
|
+
ret.append(tmp)
|
|
369
|
+
return ret
|
|
370
|
+
|
|
371
|
+
|
|
372
|
+
def GetUnitVectors(device, region):
|
|
373
|
+
ret = []
|
|
374
|
+
for i in range(dim):
|
|
375
|
+
mname = "s%s" % directions[i]
|
|
376
|
+
element_model(
|
|
377
|
+
device=device, region=region, name=mname, equation="unit%s" % directions[i]
|
|
378
|
+
)
|
|
379
|
+
ret.append(get_element_model_values(device=device, region=region, name=mname))
|
|
380
|
+
return ret
|
|
381
|
+
|
|
382
|
+
|
|
383
|
+
def SetupOutputCompare(device, region, model, variable, output):
|
|
384
|
+
k = 0
|
|
385
|
+
for i in range(dim):
|
|
386
|
+
mname = model + "_" + directions[i]
|
|
387
|
+
output[:, k] = numpy.array(
|
|
388
|
+
get_element_model_values(device=device, region=region, name=mname)
|
|
389
|
+
)
|
|
390
|
+
print("%d %s" % (k, mname))
|
|
391
|
+
k += 1
|
|
392
|
+
for j in range(nen):
|
|
393
|
+
for i in range(dim):
|
|
394
|
+
mname = model + "_" + directions[i]
|
|
395
|
+
dname = mname + ":" + variable + "@en%d" % j
|
|
396
|
+
output[:, k] = numpy.array(
|
|
397
|
+
get_element_model_values(device=device, region=region, name=dname)
|
|
398
|
+
)
|
|
399
|
+
print("%d %s" % (k, dname))
|
|
400
|
+
k += 1
|
|
401
|
+
|
|
402
|
+
|
|
403
|
+
def DoCompare(output, output_compare, number_test):
|
|
404
|
+
test2 = output[0 : nee * number_test] - output_compare[0 : nee * number_test]
|
|
405
|
+
print(numpy.linalg.norm(test2, ord=numpy.inf))
|
|
406
|
+
for row in range(number_test):
|
|
407
|
+
for col in range(nen + 1):
|
|
408
|
+
sl1 = slice(nee * row, nee * (row + 1))
|
|
409
|
+
sl2 = slice(dim * col, dim * (col + 1))
|
|
410
|
+
norm = numpy.linalg.norm(output[(sl1, sl2)] - output_compare[(sl1, sl2)])
|
|
411
|
+
if norm > 1e-4:
|
|
412
|
+
print("%d %d %g" % (row, col, norm))
|
|
413
|
+
|
|
414
|
+
# use for debugging
|
|
415
|
+
if True:
|
|
416
|
+
# for row in range(10):
|
|
417
|
+
row = 0
|
|
418
|
+
col = 0
|
|
419
|
+
sl1 = slice(nee * row, nee * (row + 1))
|
|
420
|
+
sl2 = slice(dim * col, dim * (col + 1))
|
|
421
|
+
print(output[(sl1, sl2)])
|
|
422
|
+
print(output_compare[(sl1, sl2)])
|
|
423
|
+
print(output[(sl1, sl2)] - output_compare[(sl1, sl2)])
|
|
424
|
+
|
|
425
|
+
|
|
426
|
+
def RunTest(device, region, number_test, scalar_field, derivative_variable):
|
|
427
|
+
scalar_efield = GetScalarField(device, region, "scalar_efield", scalar_field)
|
|
428
|
+
scalar_efield_derivatives = GetScalarFieldDerivatives(
|
|
429
|
+
device, region, "scalar_efield_n", scalar_field, derivative_variable
|
|
430
|
+
)
|
|
431
|
+
node_indexes = GetNodeIndexes(device, region)
|
|
432
|
+
unit_vectors = GetUnitVectors(device, region)
|
|
433
|
+
|
|
434
|
+
number_elements = len(scalar_efield) // nee
|
|
435
|
+
|
|
436
|
+
if number_test < 1:
|
|
437
|
+
number_test = number_elements
|
|
438
|
+
|
|
439
|
+
output_dims = (nee * number_elements, dim * (nen + 1))
|
|
440
|
+
output = numpy.zeros(output_dims)
|
|
441
|
+
output0 = numpy.zeros(output_dims)
|
|
442
|
+
output1 = numpy.zeros(output_dims)
|
|
443
|
+
|
|
444
|
+
ecouple = None
|
|
445
|
+
if dim == 2:
|
|
446
|
+
ecouple = get_element_model_values(
|
|
447
|
+
device=device, region=region, name="ElementEdgeCouple"
|
|
448
|
+
)
|
|
449
|
+
|
|
450
|
+
for ei in range(number_test):
|
|
451
|
+
edata = GetElementData(ei, node_indexes)
|
|
452
|
+
|
|
453
|
+
edata["matrices"] = GetNodeMatrices(edata, unit_vectors)
|
|
454
|
+
|
|
455
|
+
vector_efields = CalculateEField(edata, scalar_efield)
|
|
456
|
+
|
|
457
|
+
vector_efield_derivatives = CalculateEFieldDerivatives(
|
|
458
|
+
edata, scalar_efield_derivatives
|
|
459
|
+
)
|
|
460
|
+
|
|
461
|
+
if dim == 2:
|
|
462
|
+
CalculateFinalValues2D(edata, vector_efields, ecouple, output)
|
|
463
|
+
CalculateFinalDerivatives2D(
|
|
464
|
+
edata, vector_efield_derivatives, ecouple, output
|
|
465
|
+
)
|
|
466
|
+
elif dim == 3:
|
|
467
|
+
CalculateFinalValues3D(edata, vector_efields, output)
|
|
468
|
+
CalculateFinalDerivatives3D(edata, vector_efield_derivatives, output)
|
|
469
|
+
else:
|
|
470
|
+
raise RuntimeError("Bad Dimension %d" % dim)
|
|
471
|
+
|
|
472
|
+
CalculateFinalValuesPairs(edata, vector_efields, output0, output1)
|
|
473
|
+
CalculateFinalDerivativesPairs(
|
|
474
|
+
edata, vector_efield_derivatives, output0, output1
|
|
475
|
+
)
|
|
476
|
+
|
|
477
|
+
# For the averaged field
|
|
478
|
+
element_from_edge_model(device=device, region=region, edge_model=scalar_field)
|
|
479
|
+
element_from_edge_model(
|
|
480
|
+
device=device,
|
|
481
|
+
region=region,
|
|
482
|
+
edge_model=scalar_field,
|
|
483
|
+
derivative=derivative_variable,
|
|
484
|
+
)
|
|
485
|
+
output_compare = numpy.zeros(output_dims)
|
|
486
|
+
SetupOutputCompare(
|
|
487
|
+
device, region, scalar_field, derivative_variable, output_compare
|
|
488
|
+
)
|
|
489
|
+
DoCompare(output, output_compare, number_test)
|
|
490
|
+
|
|
491
|
+
# For the node based fields
|
|
492
|
+
element_pair_from_edge_model(device=device, region=region, edge_model=scalar_field)
|
|
493
|
+
element_pair_from_edge_model(
|
|
494
|
+
device=device,
|
|
495
|
+
region=region,
|
|
496
|
+
edge_model=scalar_field,
|
|
497
|
+
derivative=derivative_variable,
|
|
498
|
+
)
|
|
499
|
+
for i, v in enumerate((output0, output1)):
|
|
500
|
+
output_compare = numpy.zeros(output_dims)
|
|
501
|
+
n = scalar_field + ("_node%d" % i)
|
|
502
|
+
SetupOutputCompare(device, region, n, derivative_variable, output_compare)
|
|
503
|
+
DoCompare(v, output_compare, number_test)
|
|
@@ -0,0 +1,61 @@
|
|
|
1
|
+
from devsim import (
|
|
2
|
+
add_gmsh_contact,
|
|
3
|
+
add_gmsh_region,
|
|
4
|
+
create_device,
|
|
5
|
+
create_gmsh_mesh,
|
|
6
|
+
finalize_mesh,
|
|
7
|
+
write_devices,
|
|
8
|
+
)
|
|
9
|
+
|
|
10
|
+
import devsim.python_packages.pythonmesh
|
|
11
|
+
|
|
12
|
+
|
|
13
|
+
def gmsh_reader(
|
|
14
|
+
mesh, device, filename="", coordinates="", physical_names="", elements=""
|
|
15
|
+
):
|
|
16
|
+
if filename:
|
|
17
|
+
create_gmsh_mesh(mesh=mesh, file=filename)
|
|
18
|
+
else:
|
|
19
|
+
create_gmsh_mesh(
|
|
20
|
+
mesh=mesh,
|
|
21
|
+
coordinates=coordinates,
|
|
22
|
+
physical_names=physical_names,
|
|
23
|
+
elements=elements,
|
|
24
|
+
)
|
|
25
|
+
add_gmsh_region(mesh=mesh, gmsh_name="Bulk", region="bulk", material="Silicon")
|
|
26
|
+
add_gmsh_contact(
|
|
27
|
+
mesh=mesh, gmsh_name="Base", region="bulk", material="metal", name="top"
|
|
28
|
+
)
|
|
29
|
+
add_gmsh_contact(
|
|
30
|
+
mesh=mesh, gmsh_name="Emitter", region="bulk", material="metal", name="bot"
|
|
31
|
+
)
|
|
32
|
+
finalize_mesh(mesh=mesh)
|
|
33
|
+
create_device(mesh=mesh, device=device)
|
|
34
|
+
|
|
35
|
+
|
|
36
|
+
data = devsim.python_packages.pythonmesh.read_gmsh_file("gmsh_diode3d.msh")
|
|
37
|
+
coordinates = data["coordinates"]
|
|
38
|
+
elements = data["elements"]
|
|
39
|
+
physical_names = data["physical_names"]
|
|
40
|
+
|
|
41
|
+
gmsh_reader(
|
|
42
|
+
mesh="gmsh_diode3da",
|
|
43
|
+
device="gmsh_diode3da",
|
|
44
|
+
coordinates=coordinates,
|
|
45
|
+
physical_names=physical_names,
|
|
46
|
+
elements=elements,
|
|
47
|
+
)
|
|
48
|
+
gmsh_reader(mesh="gmsh_diode3db", device="gmsh_diode3db", filename="gmsh_diode3d.msh")
|
|
49
|
+
|
|
50
|
+
write_devices(device="gmsh_diode3da", file="gmsh_diode3da.msh")
|
|
51
|
+
write_devices(device="gmsh_diode3db", file="gmsh_diode3db.msh")
|
|
52
|
+
|
|
53
|
+
with open("gmsh_diode3da.msh", "r") as f:
|
|
54
|
+
file1 = f.read()
|
|
55
|
+
with open("gmsh_diode3db.msh", "r") as f:
|
|
56
|
+
file2 = f.read()
|
|
57
|
+
|
|
58
|
+
file2 = file2.replace("gmsh_diode3db", "gmsh_diode3da")
|
|
59
|
+
|
|
60
|
+
if file1 != file2:
|
|
61
|
+
raise RuntimeError("gmsh_diode3da.msh and gmsh_diode3db.msh do not match")
|
|
@@ -0,0 +1,57 @@
|
|
|
1
|
+
# Copyright 2013 DEVSIM LLC
|
|
2
|
+
#
|
|
3
|
+
# SPDX-License-Identifier: Apache-2.0
|
|
4
|
+
|
|
5
|
+
#### Small Signal simulation
|
|
6
|
+
from devsim import (
|
|
7
|
+
circuit_alter,
|
|
8
|
+
circuit_element,
|
|
9
|
+
get_circuit_node_list,
|
|
10
|
+
get_circuit_node_value,
|
|
11
|
+
get_circuit_solution_list,
|
|
12
|
+
solve,
|
|
13
|
+
)
|
|
14
|
+
|
|
15
|
+
from devsim.python_packages.simple_physics import GetContactBiasName, PrintCurrents
|
|
16
|
+
import diode_common
|
|
17
|
+
import math
|
|
18
|
+
|
|
19
|
+
# This requires a circuit element to integrated current
|
|
20
|
+
circuit_element(
|
|
21
|
+
name="V1", n1=GetContactBiasName("top"), n2=0, value=0.0, acreal=1.0, acimag=0.0
|
|
22
|
+
)
|
|
23
|
+
|
|
24
|
+
|
|
25
|
+
device = "MyDevice"
|
|
26
|
+
region = "MyRegion"
|
|
27
|
+
|
|
28
|
+
diode_common.CreateMesh2(device, region)
|
|
29
|
+
|
|
30
|
+
diode_common.SetParameters(device=device, region=region)
|
|
31
|
+
|
|
32
|
+
diode_common.SetNetDoping(device=device, region=region)
|
|
33
|
+
|
|
34
|
+
diode_common.InitialSolution(device, region, circuit_contacts="top")
|
|
35
|
+
|
|
36
|
+
# Initial DC solution
|
|
37
|
+
solve(type="dc", absolute_error=1.0, relative_error=1e-12, maximum_iterations=30)
|
|
38
|
+
|
|
39
|
+
|
|
40
|
+
diode_common.DriftDiffusionInitialSolution(device, region, circuit_contacts=["top"])
|
|
41
|
+
|
|
42
|
+
v = 0.0
|
|
43
|
+
while v < 0.51:
|
|
44
|
+
circuit_alter(name="V1", value=v)
|
|
45
|
+
solve(type="dc", absolute_error=1e10, relative_error=1e-10, maximum_iterations=30)
|
|
46
|
+
# TODO: get out circuit information
|
|
47
|
+
# PrintCurrents(device, "top")
|
|
48
|
+
PrintCurrents(device, "bot")
|
|
49
|
+
solve(type="ac", frequency=1.0)
|
|
50
|
+
cap = get_circuit_node_value(node="V1.I", solution="ssac_imag") / (-2 * math.pi)
|
|
51
|
+
print("capacitance {0} {1}".format(v, cap))
|
|
52
|
+
v += 0.1
|
|
53
|
+
|
|
54
|
+
for x in get_circuit_node_list():
|
|
55
|
+
for y in get_circuit_solution_list():
|
|
56
|
+
z = get_circuit_node_value(node=x, solution=y)
|
|
57
|
+
print(("{0}\t{1}\t{2}".format(x, y, z)))
|
|
@@ -0,0 +1,63 @@
|
|
|
1
|
+
import devsim
|
|
2
|
+
from devsim.python_packages.simple_physics import GetContactBiasName
|
|
3
|
+
import diode_common
|
|
4
|
+
|
|
5
|
+
|
|
6
|
+
def print_circuit_solution():
|
|
7
|
+
for node in devsim.get_circuit_node_list():
|
|
8
|
+
r = devsim.get_circuit_node_value(solution="dcop", node=node)
|
|
9
|
+
print("%s\t%1.15e" % (node, r))
|
|
10
|
+
|
|
11
|
+
|
|
12
|
+
device = "MyDevice"
|
|
13
|
+
region = "MyRegion"
|
|
14
|
+
|
|
15
|
+
# Set extended parameters
|
|
16
|
+
devsim.set_parameter(name="extended_solver", value=True)
|
|
17
|
+
devsim.set_parameter(name="extended_model", value=True)
|
|
18
|
+
devsim.set_parameter(name="extended_equation", value=True)
|
|
19
|
+
|
|
20
|
+
# This requires a circuit element to integrated current
|
|
21
|
+
voltage = 0.0
|
|
22
|
+
devsim.circuit_element(
|
|
23
|
+
name="V1", n1=GetContactBiasName("top"), n2=0, value=voltage, acreal=1.0, acimag=0.0
|
|
24
|
+
)
|
|
25
|
+
|
|
26
|
+
diode_common.CreateMesh2(device=device, region=region)
|
|
27
|
+
diode_common.SetParameters(device=device, region=region)
|
|
28
|
+
|
|
29
|
+
# Übergeben der Werte an SetNetDoping
|
|
30
|
+
diode_common.SetNetDoping(device=device, region=region)
|
|
31
|
+
|
|
32
|
+
diode_common.InitialSolution(device, region, circuit_contacts="top")
|
|
33
|
+
|
|
34
|
+
# Initial DC solution
|
|
35
|
+
devsim.solve(type="dc", absolute_error=1.0, relative_error=1e-12, maximum_iterations=30)
|
|
36
|
+
|
|
37
|
+
diode_common.DriftDiffusionInitialSolution(device, region, circuit_contacts=["top"])
|
|
38
|
+
|
|
39
|
+
devsim.solve(
|
|
40
|
+
type="transient_dc", absolute_error=1.0, relative_error=1e-14, maximum_iterations=30
|
|
41
|
+
)
|
|
42
|
+
|
|
43
|
+
print_circuit_solution()
|
|
44
|
+
|
|
45
|
+
devsim.circuit_alter(name="V1", value=0.7)
|
|
46
|
+
|
|
47
|
+
time_step = 1e-3
|
|
48
|
+
total_time = 1e-2
|
|
49
|
+
current_time = 0
|
|
50
|
+
|
|
51
|
+
while current_time < total_time:
|
|
52
|
+
devsim.solve(
|
|
53
|
+
type="transient_bdf1",
|
|
54
|
+
absolute_error=1e10,
|
|
55
|
+
relative_error=1e-10,
|
|
56
|
+
maximum_iterations=30,
|
|
57
|
+
tdelta=time_step,
|
|
58
|
+
charge_error=1,
|
|
59
|
+
)
|
|
60
|
+
|
|
61
|
+
print_circuit_solution()
|
|
62
|
+
|
|
63
|
+
current_time += time_step
|