Lumerical Python API学习之补充笔记

一、笔记1

1.1.关于SYS

在导入之前添加 Python代码解释

当我们导入一个模块时： import xxx ，默认情况下python解释器会搜索当前目录、已安装的内置模块和第三方模块。
搜索路径存放在sys模块的path中。【即默认搜索路径可以通过sys.path打印查看】

来自 https://www.cnblogs.com/hls-code/p/15337302.html

sys.path.append()

sys.path是一个列表 list ,它里面包含了已经添加到系统的环境变量路径。
当我们要添加自己的引用模块搜索目录时，可以通过列表 list 的 append()方法；

sys.path.append()

对于需要引用的模块和需要执行的脚本文件不在同一个目录时，可以按照如下形式来添加路径：
【例如：
①导入的XX包在另一个项目文件中，在自己写的程序中需要用到XX包。
②所以我们在运行自己写的程序时，首先加载导入的XX包，加载的时候python解释器会去sys.path默认搜索路径去搜索。
③如果通过sys.path中的路径可以搜索到XX包，然后加载。
④如果无法通过sys.path中的路径搜索到XX包，即说明自己的程序中引用的XX包，与自己程序脚本所在目录不在同一个路径。（无法在自己的程序脚本中根据默认搜索路径查找到XX包）
⑤然后我们就需要将XX包的搜索路径添加到自己程序脚本的默认搜索路径中，重新运行自己的程序脚本，先搜索XX包再加载XX包。
】

import sys  
sys.path.append(’需要引用模块的地址')
# sys.path.append("..")   # 这代表添加当前路径的上一级目录

【注意】：这种方法是运行时修改，脚本运行后就会失效。

sys.path.append('..')括号里这两个点是什么意思？

这是目录的意思，即代表上一级目录。
通过这种方式，python程序会在上一级查找相应的其他python包或者文件。

sys.path.append('..\..')还有类似的sys.path.append('../..') 就是代表当前位置得上两级的目录地址。
改变当前python脚本的默认搜索路径的第二种方式
把路径添加到系统的环境变量，或把该路径的文件夹放进已经添加到系统环境变量的路径内。
环境变量的内容会自动添加到模块搜索路径中。

1.2.关于OS

os.path.dirname(path)
语法：os.path.dirname(path)
功能：去掉文件名，返回目录

来自 https://blog.csdn.net/weixin_38470851/article/details/80367143

print(os.path.dirname("E:/Read_File/read_yaml.py"))
 #结果：
E:/Read_File 

os.path.dirname(__file__)

先了解一下__file__

print(__file__) 
#结果
 E:/Read_File/read_yaml.py

可以看出__file__表示了当前文件的path

那么就可以了解到os.path.dirname((__file__)和os.path.dirname(“E:/Read_File/read_yaml.py”)是一个意思
再根据os.path.dirname(path)的用法，得出os.path.dirname((__file__)就是得到当前文件的绝对路径

print(os.path.dirname(__file__)) 
#结果： 
E:/Read_File

若print os.path.dirname(file)所在脚本是以绝对路径运行的，则会输出该脚本所在的绝对路径，若以相对路径运行，输出空目录

二、笔记2

2.1.反斜杠在Script中的使用

2.2.Script的function函数

来自 https://support.lumerical.com/hc/en-us/articles/360034923573

使用 function 命令创建您自己的 Lumerical 脚本函数，这使您可以编写更多可重用、可维护和可理解的代码。 用户定义的函数支持任意输入和输出变量。

用户定义的函数可以在您的主脚本文件中定义，也可以保存在单独的文件中，并且必须在全局范围内定义。 如果将函数保存在单独的文件中，请确保脚本文件名与函数名不同。 它还必须不同于任何标准的 Lumerical 脚本函数。

示例：

定义一个函数，将输入数字四舍五入到最接近的偶数

function even_floor(a) {
    return floor(a) - mod(floor(a),2);
}

注：命令 floor 将输入数据入舍为小于或等于其值的整数。
mod输出两数相除后的余数（除模）

函数也可以嵌套到其他函数定义中。 以下示例显示使用 add 函数创建另一个具有 4 个输入参数的 add 函数：

function add(a, b){
    return a+b;
}
function add4(i, j, k, l){
    return add(add(i, j), add(k, l));
}

注意，add函数需要在全局范围内定义，如果定义在add4函数内部，则无法识别。 下面的函数定义会报错：

function add4(i, j, k, l){  
function add(a, b) {
return a+b;
}
   return add(add(i, j), add(k, l)); 
}
Error: add is not a valid function or variable name

创建并调用保存在不同脚本文件中的函数。

第 1 步：假设 myfunction_library.lsf 中保存了以下函数。

function func1(x,y) {
return x^2+y^2;
}

function func2(x,y) {
return x*y;
}

第 2 步：运行包含函数的文件以将函数加载到脚本解释器中。 加载函数后，可以在后续命令中使用它们。

myfunction_library;
a=1;
b=2;
?out = func1(a,b) +func2(a,b);
result: 
7 

以上两个文件应保存在一个文件夹中，不然会报错。

三、笔记3——运行结果

3.1.运行结果1

在此处发现一个问题，在Pycharm中运行时，打开的FDTD Solutions会闪退，而自带的IDLE不会。

要解决该办法，目前找到的方式是

importtime
while1:
time.sleep(10)

利用无限循环+延迟函数，实现悬停。

3.2.运行结果2

未修改参数之前：

修改后：

3.3.运行结果3

下面这一段都运行不了

# Go up two parents from the rectangle in "B" group#从“B”组的矩形中上去两个父母
aGroup = bRect.getParent().getParent()

# Print the names of all members of "A" group
for child in aGroup.getChildren():
   print child["name"]

四、笔记4

addfdtd - Script command

来自 https://support.lumerical.com/hc/en-us/articles/360034924173

将 FDTD 求解器区域添加到仿真环境。 求解器区域的范围决定了 FDTD 中的模拟体积/面积。

例子

以下脚本命令将添加 3D FDTD 求解器区域、设置其尺寸并运行模拟。 该脚本假定模拟环境已经设置了几何图形和源/监视器。

addfdtd;
set("dimension",2);  #  1 = 2D, 2 = 3D
set("x",0);
set("x span",2e-6);
set("y",0);
set("y span",5e-6);
set("z",0);
set("z span",10e-6);
run;

五、笔记5——数据集的介绍

Introduction to Lumerical datasets

来自 https://support.lumerical.com/hc/en-us/articles/360034409554

Lumerical 数据集是将一组相关矩阵收集到一个方便的对象中的结构化数据对象。 为了介绍这个概念，我们将首先提供两个示例。 附加信息如下。

例1 – 反射与半径和高度（矩阵数据集）-matrix dataset

假设您有一个参数扫描，它测量粒子的反射作为粒子半径和高度的函数。 保存此信息通常需要 3 个矩阵变量。 2D 矩阵 R 包含来自每个模拟的反射值，而 1D 矢量半径和高度包含相关的位置值。

数据集对象可用于将所有三个矩阵收集到单个数据集变量中。

以下脚本代码生成一些示例数据，创建一个 R(radius,height) 数据集，最后创建几个数据图。

# create example results
radius = 0:10; 
height = 1:0.1:3;
reflection = randmatrix(length(radius),length(height)); 
# create Reflection dataset
R = matrixdataset("R"); # initialize dataset 初始化名为R的数据集
R.addparameter("radius",radius); # add radius parameter 添加半径参数
R.addparameter("height",height); # add height parameter 添加高度参数
R.addattribute("R",reflection); # add reflection attribute 添加反射属性
# plot data
image(radius,height,reflection); # use original matrices 用原来的矩阵
image(R.radius,R.height,R.R);  # use dataset 使用数据集
# send dataset to visualizer
visualize(R); 

例2 – 来自监视器的电场数据（直线数据集）-rectilinear dataset

FDTD 和 MODE 中的场监视器用于计算和保存空间电场数据。 监视器内的原始电场数据分布在几个矩阵中：每个矢量场分量存储在一个矩阵（Ex、Ey、Ez）中，四个相关的位置矢量（x、y、z、f）也存储为 单独的矩阵。

数据集可用于将所有这些信息收集到单个数据集变量中。 右图显示了存储电场每个分量的三个矩阵 Ex、Ey、Ez。 它还显示了相关的位置向量 x、y、z。 所有这些信息都可以存储在单个数据集变量中。

注意：电场矩阵通常有第 4 维（时间或频率），但由于很难用图形表示第 4 维，因此图中未包括此维！

以下脚本代码显示了如何从 FDTD 中的频率监视器获取原始数据（使用 getdata），以及如何从该数据手动创建数据集。 它还展示了如何通过单个命令（使用 getresult）直接从监视器中获取电场数据集。 最后一部分展示了如何创建一些数据图

# monitor name
m="monitor";#监视器名称
# get individual data elements with getdata
x=getdata(m,"x");
y=getdata(m,"y");
z=getdata(m,"z");
f=getdata(m,"f");
Ex=getdata(m,"Ex");
Ey=getdata(m,"Ey");
Ez=getdata(m,"Ez");
# manually create the electric field dataset from the raw data
# initialize dataset and provide spatial position vectors
# 从原始数据手动创建电场数据集
# 初始化数据集并提供空间位置向量
E_manual = rectilineardataset("E_manual",x,y,z);  # 初始化名为E_manual的数据集，[empty] vs x, y, z
# add additional parameter: frequency 添加另外的参数，频率
E_manual.addparameter("lambda",c/f,"f",f);      
# add vector electric field attribute 添加矢量电场属性
E_manual.addattribute("E",Ex,Ey,Ez);        
# all of the above commands can be avoided with a single getresult command
# 上述所有命令都可以通过一个 getresult 命令来避免
E_fromMonitor = getresult(m,"E");
# plot Ex(x,y) at the first z value and first frequency point
# 在第一个 z 值和第一个频率点绘制 Ex(x,y)
to_plot = pinch(pinch(Ex,4,1),3,1);  # use original matrices #用原来的矩阵
image(x,y,to_plot);          # use original matrices    
to_plot = pinch(pinch(E_manual.Ex,4,1),3,1); # use dataset #用数据集
image(E_manual.x,E_manual.y,to_plot);     # use dataset
# Plot the entire dataset with the Visualizer
visualize(E_manual);

注意：Ex的大小是XYZN，其中X是位置向量x的大小，Y,Z同理，N是频点数。
pinch(Ex,4,1)的大小为XYZ，删除了频点数那一维，取1是指取了第一个频点的数据
pinch(pinch(Ex,4,1),3,1)则是XY，进一步删除了位置向量z的那一维，取第一个z值

其中Nk，k=x,y,z是坐标向量的长度，Npi是第i个参数的长度。 如果数据集是 2D 或 1D，那么您将拥有单维维度，因此一个或多个 Nk=1。 这些尺寸可以pinch - 脚本（ pinch - Script command）命令删除。

数据集中有什么？ 图标和“？” 操作符

结果视图和脚本工作区窗口提供了当前监视器结果和脚本变量的列表。 每种类型的变量（数据集、矩阵、字符串、非结构化数据）使用不同的图标。 对于数据集，预览列提供数据集中属性和参数的列表。 在下面的屏幕截图中，“E”数据集包含一个属性 (E)，它是 4 个参数 (x,y,z, lambda/f) 的函数。


这 ‘？’ 运算符可用于将相同的信息输出到脚本提示符（script prompt）。

?E_field = getresult("monitor","E");
 E vs x, y, z, lambda/f

要输出实际的属性或参数值，请执行以下操作：

?E_field.x;  # output the 'x' position vector
 result: 
 -6.58393e-006 
 -6.5442e-006 
 -6.50447e-006  
 ..... 

访问数据集中的数据：点 ‘.’ 操作符
可以使用点“.”访问存储在数据集中的单个矩阵。 例如，要从电场数据集中获取原始 x、y 和 Ex 数据，请执行以下操作：

x = E_field.x;
y = E_field.y;
Ex = E_field.Ex;

数据集类型

矩阵数据集 （Matrix dataset ）- 没有空间参数的数据（例如示例 1）将使用矩阵数据集。

直线空间数据集（Matrix dataset ） - 具有来自直线网格（例如 FDTD 网格）的空间信息的数据将使用直线数据集。

非结构化空间数据集（Unstructured spatial dataset ） - 具有由任意 x/y/z 坐标和连接矩阵定义的空间信息的数据（例如设备中的有限元网格）
（也许与定义非方形的网格相关）

任意非结构化数据集 （Arbitrary unstructured dataset ）- 任何数据类型（如矩阵、字符串、数据集）都可以添加到结构对象中。

这个有点儿像python的字典类型

任何数据类型（如矩阵、字符串、数据集）都可以添加到结构对象中

对数据集的操作

数据集的主要目的是作为一种方便的方式来管理和存储相关数据的集合。 无法将数学运算（例如加法）直接应用于数据集对象。 相反，必须使用点运算符将所需数据放入矩阵中。 然后可以将该操作应用于矩阵。 您可以选择创建一个新数据集来存储结果，或者您可以简单地将结果保留为标准矩阵。

标量和矢量属性

可以将标量和矢量属性添加到数据集。

标量

命令

R.addattribute("R",reflection); # add reflection attribute

将标量“R”添加到具有相同名称的数据集。 要访问“R”原始数据，请使用：

R.R;

向量

命令

E.addattribute("E",Ex_raw,Ey_raw,Ez_raw); # add vector E field attribute

将向量“E”添加到具有相同名称的数据集。 在这种情况下，我们可以通过以下方式访问原始“E”数据：

E.Ex; # get Ex component
E.Ey; # get Ey component
E.Ez; # get Ez component
E.E2; # get |E|^2
E.E;  # get all components in a single matrix. An extra dimension of length 3 will be added to the matrix, for each vector component.

六、笔记6——getv()和putv()

6.1.getv

来自 https://support.lumerical.com/hc/en-us/articles/360043683873

转换数据类型的快速参考指南。

String

当在 Python 中执行 getv() 时，将 Lumerical 字符串变量的名称作为参数传递，该函数将把该变量的字符串值返回给 Python 环境。

with lumapi.FDTD(hide = True) as fdtd:

    #######################
    #Strings
    Lumerical = 'Lumerical Inc' # 定义一个名为Lumerical的字符串，其内容是Lumerical Inc
    fdtd.putv('Lum_str',Lumerical) # 把这个字符串以Lum_str的名字放入Lumerical环境
    print(type(fdtd.getv('Lum_str')),str(fdtd.getv('Lum_str')))#通过Lum_str的名字获取该字符串

返回

<class 'str'> Lumerical Inc

实数Real Number

当在 Python 中执行 getv() 时，将一个数字 lsf 变量的名称作为参数传递，该函数将把该变量的值返回给 Python 环境。 Lumerical 不支持整数类型，将作为浮点类型返回。

 with lumapi.FDTD(hide = True) as fdtd:
    #Real Number
    n = int(5)
    fdtd.putv('num',n)
    print('Real number n is returned as ',type(fdtd.getv('num')),str(fdtd.getv('num')))

返回

Real number n is returned as <class 'float'> 5.0

复数Complex Number

当在 Python 中执行 getv() 时，将 Lumerical 复数变量的名称作为参数传递，此函数将返回一个带有单个元素的 numpy 数组到 Python 环境。 同样，传递复数要求将它们封装在单个元素数组中。 有关更多信息，请参阅 lumapi.putv()。 或者，可以使用 lumapi.eval() 方法来定义一个复杂的变量。

 with lumapi.FDTD(hide = True) as fdtd:
    #Complex Numbers 
    z = 1 + 1.0*1j
    Z = np.zeros((1,1),dtype=complex) + z
    fdtd.putv('Z',Z[0])
    fdtd.eval('z = 1 +1i;')
    print('Complex number Z is returned as ',type(fdtd.getv('Z')),str(fdtd.getv('Z')))
    print('Complex number z is returned as ',type(fdtd.getv('z')),str(fdtd.getv('z')))

返回

Complex number Z is returned as  <class 'numpy.ndarray'> [[1.+1.j]]
Complex number z is returned as  <class 'numpy.ndarray'> [[1.+1.j]]

注意：不同的虚数单位约定。 在 python 中，复数使用“j”初始化，而在 Lumerical 中，使用“i”完成。

矩阵Matrix

当在 Python 中执行 getv() 时，将 Lumerical 矩阵的名称作为参数传递，该函数会将矩阵变量的值作为 numpy 数组返回到 Python 环境。 正如我们之前看到的，这些支持复杂的数据。 这在定义向量、矩阵或调用返回数组的 Lumerical 方法时很有用。

 with lumapi.FDTD(hide = True) as fdtd:
    ##      Vector
    rad = np.linspace(1,11)*1e-6 #np array
    height = np.arange(1,3,0.1)*1e-6 #np array
    #Pass to Lumerical 传给Lumerical
    fdtd.putv('rad',rad)
    fdtd.putv('height',height)
    #Get from Lumerical 从Lumerical中获取
    rad_rt=fdtd.getv('rad')
    height_rt=fdtd.getv('height')
    print('After round trip rad is ', type(rad_rt))
    print('After round trip height is ', type(height_rt))

    ###     Matrix
    M1 = np.matrix([[0,0.5,0.3,0.4,0.5,0.6], [0,2,3,4,5,6],[0,2.2,3.5,4.4,5.5,6.5]])
    M2 = np.zeros((2,2),dtype=complex)
    #Pass to Lumerical
    fdtd.putv('M1',M1)
    fdtd.putv('M2',M2)
    #Get from Lumerical
    M1_rt=fdtd.getv('M1')
    M2_rt=fdtd.getv('M2')
    print('The matrix M is ', type(M1_rt), str(M1_rt))
    print('The np array M2 is ', type(M2_rt),  str(M2_rt))

    #       Return from Lumerical
    A = fdtd.randmatrix(2,3)
    B = fdtd.zeros(1,5)
    print('The matrix A is ', type(A),  str(A))
    print('The matrix B is ', type(B),  str(B))

返回

After round trip rad is  <class 'numpy.ndarray'>
After round trip height is  <class 'numpy.ndarray'>
The matrix M is  <class 'numpy.ndarray'> [[0.  0.5 0.3 0.4 0.5 0.6]
 [0.  2.  3.  4.  5.  6. ]
 [0.  2.2 3.5 4.4 5.5 6.5]]
The np array M2 is  <class 'numpy.ndarray'> [[0.+0.j 0.+0.j]
 [0.+0.j 0.+0.j]]
The matrix A is  <class 'numpy.ndarray'> [[0.806134   0.99917605 0.23325807]
 [0.69062098 0.53113442 0.18275802]]
The matrix B is  <class 'numpy.ndarray'> [[0. 0. 0. 0. 0.]]

元胞数组Cell array

当在 Python 中执行 getv() 时，将 Lumerical 单元的名称作为参数传递，此函数会将单元作为列表返回到 Python 环境。

元胞数组是有序的，可以包含上面已经提到的任何类型的数据，它们本身和结构。 类似地，python 列表是有序的，可以包含许多类作为元素。 这些数据类型在逻辑上是等价的。

with lumapi.FDTD(hide = True) as fdtd:
#Cells
    C1 = [ i for i in range(11)] #list
    C2 = [[1,2,3],[4,5,6]] #list of lists
    C3 = [C1,C2,'string', 3.59]
    #Pass to Lumerical
    fdtd.putv('C_1',C1)
    fdtd.putv('C_2',C2)
    fdtd.putv('C_3',C3)
    #Get from Lumerical
    C1_rt=fdtd.getv('C_1')
    C2_rt=fdtd.getv('C_2')
    C3_rt=fdtd.getv('C_3')
    print('The cell C1 is ', type(C1_rt),  str(C1_rt))
    print('The cell C2 is ', type(C2_rt),  str(C2_rt))
    print('The cell C3 is ', type(C3_rt),  str(C3_rt))

返回

The cell C1 is  <class 'list'> [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
The cell C2 is  <class 'list'> [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]
The cell C3 is  <class 'list'> [[0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0], [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]], 'string', 3.59]

结构Struct

当在 Python 中执行 getv() 时，将 Lumerical 结构的名称作为参数传递，该函数会将结构作为字典返回到 Python 环境。

结构由字段索引，但不排序，并且可以包含上面提到的任何数据类型及其本身作为成员。 类似地，python 字典是按键索引的，并且可以包含许多类作为元素。 在 Python 中执行 getv() 时，将 struct lsf 变量的名称作为参数传递，此函数会将单元作为列表返回到 Python 环境。

with lumapi.FDTD(hide = True) as fdtd:
    #Struct
    D = {'greeting' : 'Hello World',                       # String data
          'pi' : 3.14,                                     # Double data 
          'm' : np.array([[1.,2.,3.],[4.,5.,6.]]),         # Matrix data   
          'nested_struct' : { 'e' : 2.71 } }               # Struct 
    fdtd.putv('Dict', D)
    D_rt = fdtd.getv('Dict')
    print('The dictionary D is ', type(D_rt),  str(D_rt))

返回

The dictionary D is  <class 'dict'> {'greeting': 'Hello World', 'm': array([[1., 2., 3.],
       [4., 5., 6.]]), 'nested_struct': {'e': 2.71}, 'pi': 3.14}

会发现返回的不带有顺序

数据集Datasets

当 Lumerical 数据集返回到 Python 环境时，它们将被转换为 Python 字典。 有关更多信息，请参阅数据传递。
注意：
以前版本的 API 使用 getVar() 方法。 尽管此语法仍然有效，但不会继续受支持。 有关从 Python 驱动 Lumericals 工具的已弃用技术的更多信息，请参阅会话管理 -python API（Session Management -python API）。

注意：
以前版本的 API 使用 getVar() 方法。 尽管此语法仍然有效，但不会继续受支持。 有关从 Python 驱动 Lumericals 工具的已弃用技术的更多信息，请参阅会话管理 -python API（Session Management -python API）。

6.2.putv

来自 https://support.lumerical.com/hc/en-us/articles/360043683073

一个 Python 函数，它通过 Python API 将本地 Python 环境中的变量放入活动的 Lumerical 会话中。

转换数据类型的快速参考指南。

字符串String

在 Python 中执行 putv() 时，使用 Lumerical 变量的名称，并将字符串变量作为参数传递； 在 Lumerical 会话中创建具有所需名称和字符串值的字符串变量。

其示例代码与getv()相同不做赘述

注意：
以前版本的 API 使用 putString()、putDouble()、putMatrix()、putList() 和 putStruct() 方法。 尽管此语法仍然有效，但不会继续受支持。 有关从 Python 驱动 Lumerical 工具的已弃用技术的更多信息，请参阅会话管理。