PotatoMaxwell/mxpic_simu
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

repo build

Browse Source
This commit is contained in:
=
2026-06-08 15:46:41 +08:00
parent a889107aea
commit a1db2d9bc4
20 changed files with 2399 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
simulation/Lumerical/GDS_SIMU_DEVICE_2X2.lsf
+295
View File
@@ -0,0 +1,295 @@
function FUNC_DEVICE_2X2(instPath)
{
inst = read(instPath);
eval(inst);
jsonload(jsonPath);
HwaferMax = 0;
for(idx=1;idx<=length(layers.numbers);idx=idx+1){
if (iscell(layers.numbers)){
layer = num2str(layers.numbers{idx}) + ":" + num2str(layers.datatype{idx});}
else{
layer = num2str(layers.numbers(idx)) + ":" + num2str(layers.datatype(idx));}
if (iscell(layers.heights)){
Hwafer = layers.heights{idx}*1e-6;}
else{
Hwafer = layers.heights(idx)*1e-6;}
gdsimport(gdspath, devName, layer,wafer.material, 0, Hwafer);
#gdsimport(folder + devName + ".gds", devName, layer,wafer.material, 0, Hwafer);
#set("name","device");
if (Hwafer>HwaferMax)
{
HwaferMax = Hwafer;
}
}
## output ports
# HwaferMax = Hwafer;
zOffset = HwaferMax/2*1e+6;
mx_simu_area('FDTD',[FDTD.x,FDTD.y,FDTD.z+zOffset]*1e-6,
[FDTD.dx,FDTD.dy,FDTD.dz]*1e-6,FDTD.mesh_order,[40,40,40]*1e-6,'PML',10e+5);
portList = ports.names;
for (idx=1;idx<=length(portList);idx=idx+1)
{
portName = portList{idx};
eval("port_struct = ports."+portName+";");
if (port_struct.a < 0) { port_struct.a = port_struct.a + 360; }
if ( 45<=port_struct.a and port_struct.a<135 )
{
portsType = -2;
portsSZ = [port_struct.width,0,port_struct.height]*1e-6;
}
else if (225<=port_struct.a and port_struct.a<315)
{
portsType = 2;
portsSZ = [port_struct.width,0,port_struct.height]*1e-6;
}
else if (135<=port_struct.a and port_struct.a<225)
{
portsType = 1;
portsSZ = [0,port_struct.width,port_struct.height]*1e-6;
}
else if (port_struct.a<45 or port_struct.a>=315)
{
portsType =-1;
portsSZ = [0,port_struct.width,port_struct.height]*1e-6;
}
mx_power_monitor(portName,[port_struct.x,port_struct.y,zOffset]*1e-6,
portsSZ,abs(portsType)) ;
set("override global monitor settings",1);
set("frequency points",FDTD.Trans_sample_points);
mx_mode_expansion(portName+'_modes',[port_struct.x,port_struct.y,zOffset]*1e-6,
portsSZ,abs(portsType),0,
[abs(port_struct.radius)*1e-6,
sign(port_struct.radius)*sign(portsType)*180],1,FDTD.wl*1e-6,portName);
if (iscell(modes)){modes = [modes{1}];}
set("selected mode numbers",modes);
if ( abs(port_struct.a) <= 45 or abs(port_struct.a) > 315)
{
set('theta',port_struct.a);
set('phi',0);
}
else if ( abs(port_struct.a) > 135 and abs(port_struct.a) <= 225)
{
set('theta',port_struct.a);
set('phi',0);
}
else{
set('theta',90-port_struct.a);
set('phi',90);
}
}
mx_power_monitor('z1',[mont.z1.x,mont.z1.y,zOffset]*1e-6,
[mont.z1.dx,mont.z1.dy,0]*1e-6,3) ;
set("override global monitor settings",1);
set("frequency points",FDTD.Field_sample_points);
## adding input ports
input_struct = ports.a1;
if (input_struct.a < 0) { input_struct.a = input_struct.a + 360; }
if ( 45<=input_struct.a and input_struct.a<135 )
{
inputType = -2;
portsSZ = [input_struct.width,0,input_struct.height]*1e-6;
input_theta = 90-input_struct.a;
input_phi = 0;
}
else if (225<=input_struct.a and input_struct.a<315)
{
inputType = 2;
portsSZ = [input_struct.width,0,input_struct.height]*1e-6;
input_theta = 270-input_struct.a;
input_phi = 0;
}
else if (135<=input_struct.a and input_struct.a<225)
{
inputType = -1;
portsSZ = [0,input_struct.width,input_struct.height]*1e-6;
input_theta = input_struct.a - 180;
input_phi = 0;
}
else if (input_struct.a<45 or input_struct.a>=315)
{
inputType = 1;
portsSZ = [0,input_struct.width,input_struct.height]*1e-6;
input_theta = input_struct.a;
input_phi = 0;
}
mx_mode_source('a1_input',[input_struct.x,input_struct.y,zOffset]*1e-6,
portsSZ,inputType,0,
[abs(input_struct.radius)*1e-6,sign(input_struct.radius)*sign(inputType)*90],FDTD.sourceMode,FDTD.wl*1e-6);
set("theta",input_theta);
set("phi",input_phi);
## setting FDTD configurations
select("FDTD");
set("background material",clad.material);
if (FDTD.GPUOn == 1){
setnamed("FDTD", "express mode", true);
setresource("FDTD","GPU", true);
setresource("FDTD", 1, "GPU Device", "Auto");
set('z min bc','PML');
}
else {
setnamed("FDTD", "express mode", false);
setresource("FDTD","GPU", false);
if (length(layers.numbers)==1){
set('z min bc','symmetric');}
else {set('z min bc','PML');}
}
save(folder+"\\"+devName+"_simu.fsp");
#save("DEVICE_2X2.fsp");
}
function DATA_RETRIEVE_DEVICE_2X2(instPath)
{
inst = read(instPath);
eval(inst);
jsonload(jsonPath);
portList = ports.names;
save_cmd = "";
for (idx=1;idx<=length(portList);idx=idx+1)
{
portData = struct;
portData.name = portList{idx};
portData.power = getresult(portData.name,"T");
portData.modes = getresult(portData.name+"_modes","expansion for input");
E = getresult(portData.name,"E");
H = getresult(portData.name,"H");
x = E.x;
y = E.y;
z = E.z;
cx = floor(length(x)/2)+1;
cy = floor(length(y)/2)+1;
cz = floor(length(z)/2)+1;
## wavelength length
sz_wl = size(E.E,4);
step = floor((sz_wl-1)/(FDTD.Field_sample_points-1));
idxSect = [1:step:sz_wl+1];
E_save = E;
H_save = H;
E_save = matrixdataset;
E_save.addparameter("x",E.x);
E_save.addparameter("y",E.y);
E_save.addparameter("z",E.z);
E_save.addparameter("lambda",E.lambda(1:step:end));
E_save.addattribute("E",E.E(:,:,:,1:step:end,:));
H_save = matrixdataset;
H_save.addparameter("x",H.x);
H_save.addparameter("y",H.y);
H_save.addparameter("z",H.z);
H_save.addparameter("lambda",H.lambda(idxSect));
H_save.addattribute("H",H.H(:,:,:,idxSect,:));
portData.E = E_save;
portData.H = H_save;
## Center electric field of the monitor
Ecenter = E.E(cx,cy,cz,:,:); ## (x,y,z,wl,Ex/Ex/Ez)
Hcenter = H.H(cx,cy,cz,:,:); ## (x,y,z,wl,Ex/Ex/Ez)
portData.Ecenter = Ecenter;
portData.Hcenter = Hcenter;
eval(portData.name + " = portData;");
save_cmd = save_cmd + portData.name + ",";
}
if (find(portList=="a1") and find(portList=="b1")){
Ephase_11 = unwrap(angle(b1.Ecenter) - angle(a1.Ecenter));
Hphase_11 = unwrap(angle(b1.Hcenter) - angle(a1.Hcenter));
save_cmd = save_cmd + "Ephase_11" + "," + "Hphase_11" + ",";
}
if (find(portList=="a2") and find(portList=="b2")){
Ephase_22 = unwrap(angle(b2.Ecenter) - angle(a2.Ecenter));
Hphase_22 = unwrap(angle(b2.Hcenter) - angle(a2.Hcenter));
save_cmd = save_cmd + "Ephase_22" + "," + "Hphase_22" + ",";
}
if (find(portList=="a1") and find(portList=="b2")){
Ephase_12 = unwrap(angle(b2.Ecenter) - angle(a1.Ecenter));
Hphase_12 = unwrap(angle(b2.Hcenter) - angle(a1.Hcenter));
save_cmd = save_cmd + "Ephase_12" + "," + "Hphase_12" + ",";
}
if (find(portList=="a2") and find(portList=="b1")){
Ephase_21 = unwrap(angle(b1.Ecenter) - angle(a2.Ecenter));
Hphase_21 = unwrap(angle(b1.Hcenter) - angle(a2.Hcenter));
save_cmd = save_cmd + "Ephase_21" + "," + "Hphase_21" + ",";
}
z1= struct;
z1.E = getresult("z1","E");
z1.H = getresult("z1","H");
Ex = getresult("z1","Ex");
Ey = getresult("z1","Ey");
Ez = getresult("z1","Ez");
savefname = devName+"_results.mat";
#matlabsave(savefname,b1,b2,z1);
eval("matlabsave(savefname,"+save_cmd+"z1);");
}
simulation/Lumerical/mx_analysis_lib.lsf
+212
View File
@@ -0,0 +1,212 @@
function mx_sweep(sweeps,run_on){
#addsweep(0);
## NOTICE : this can only be used in one-dimentional result calculation
## NOTICE : such as [T .vs. lambda]
#### @ sweeps: struct ####
#### @ sweeps: [var_names={'width','radius','wavelength'...}]
#### @ sweeps: width = [w1:dw:w2]
#### @ radius = [r1:dr:r2]
addsweep(0);
sweep_name = 'mx_sweep';
deletesweep(sweep_name);
setsweep("sweep", "name", sweep_name);
setsweep(sweep_name,"type","Ranges");
ins_temp = 'var_temp = sweeps.' + sweeps.var_names{1} + ';';
eval(ins_temp);
setsweep(sweep_name,"number of points",length(var_temp));
result_data = zeros(length(var_temp),length(sweeps.result_names));
for (idx_vars=1;idx_vars<=length(sweeps.var_names);idx_vars=idx_vars+1){
para = struct;
para.Name = sweeps.var_names{idx_vars};
para.Type = sweeps.var_types{idx_vars};
para.Parameter = sweeps.var_select{idx_vars};
ins_temp = 'var_temp = sweeps.' + sweeps.var_names{idx_vars} + ';';
eval(ins_temp);
para.Start = var_temp(1);
para.Stop = var_temp(end);
addsweepparameter(sweep_name, para);
}
for (idx_rsult=1;idx_rsult<=length(sweeps.result_names);idx_rsult=idx_rsult+1){
result = struct;
result.Name = sweeps.result_names{idx_rsult};
result.Result = sweeps.result_select{idx_rsult};
addsweepresult(sweep_name, result);
}
if (run_on) {
runsweep;
for (idx_result=1;idx_result<=length(sweeps.result_names);idx_result=idx_result+1){
result_data(:,idx_result) = getsweepdata(sweep_name,sweeps.result_names{idx_result});
}
}
################################### RESULT ##################################################
sweep_cur = sweeps;
sweep_cur.result = result_data;
return sweep_cur;
}
##### FWM analysis lib #####
##### FWM calculation pack #####
##### @ freq_pump : pumping frequency, vector of 1*2
##### @ freq_signal: signal frequency, single scalar
##### @ mode_idx : vector of 1*4, [p,p,l,s] denoted
##### @ mode_pol : vector of 1*4, [p,p,l,s] denoted
##### @ wg: struct of {width, bend radius}
##### @ ONLY operates in FDE !!!! #####
function mx_FWM_analysis(freq_pump,freq_signal,mode_idx,mode_pol,wg_bend){
##### Select the target modes #####
freq_idler = freq_pump(1) + freq_pump(2) - freq_signal;
freq_range = [freq_pump,freq_signal,freq_idler];
mode_neff = zeros(1,4);
for (idx_mode=1;idx_mode<=4;idx_mode=idx_mode+1){
temp = mx_get_mode_data(c/freq_range(idx_mode),mode_pol{idx_mode},mode_idx(idx_mode),wg_bend,{'neff'});
mode_neff(idx_mode) = temp.neff;
}
wavelengths = c/freq_range;
wl_neff = wavelengths/mode_neff;
k_vector = 2*pi/wl_neff;
phase_mismatch = sum(k_vector*[1,1,-1,-1]);
return phase_mismatch;
}
##### Phase Matched Coupler calculation pack #####
##### NOTICE : this is coupled by TE0/TM0 by default #####
function mx_DC_analysis(wafer,width_seed,wl,gap,neff,bend,outer_side,mode_idx,mode_pol){
cur_file_name = currentfilename;
#load('Temp_workspace.lms');
switchtolayout;
#deleteall;
cladding = wafer.cladding;
max_itn = 5;
mesh_grids = [20,20,20]*1e-9;
##### Adding two waveguides to the strcuture #####
#mx_FDE_strip(wafer,width_seed);
#mx_simu_area('FDE_y',[0,0,0],[7e-6,10e-6,3e-6],2,mesh_grids,'Metal',10000);
width_cur = width_seed;
neff_sweep = mx_get_mode_data(wl,mode_pol,0,bend,{'neff'});
run;
setanalysis('use max index',0);
setanalysis('n',neff_sweep.neff);
findmodes;
width_step = 0.002e-6;
for (itn=1;itn<=max_itn;itn=itn+1){
width_delta = [-0.01:0.002:0.01]*1e-6;
width_sweep = width_cur+width_delta;
radius_sweep = width_sweep/2 + gap + outer_side;
#### Adding single sweep ####
if (bend>0){
sweeps = struct;
sweeps.var_names = {'width','radius'};
sweeps.radius = radius_sweep;
sweeps.width = width_sweep;
sweeps.var_select = {'::model::waveguide::x span','::model::FDE::bend radius'};
sweeps.var_types = {'Length','Length'};
sweeps.result_names = {'TE0_neff'};
sweeps.result_select = {'::model::FDE::data::mode'+num2str(mode_idx)+'::neff'};
sweeps.bound_para_idx = [1,2];
neff_data = mx_sweep(sweeps,1);
neff_data = abs(neff_data.result);
mismatch = neff*bend - neff_data*radius_sweep;
}
else {
sweeps = struct;
sweeps.var_names = {'width'};
sweeps.width = width_sweep;
sweeps.var_select = {'::model::WG::x span'};
sweeps.var_types = {'Length'};
sweeps.result_names = {'TE0_neff'};
sweeps.result_select = {'::model::FDE::data::mode'+num2str(mode_idx)+'::neff'};
sweeps.bound_para_idx = [1];
neff_data = mx_sweep(sweeps,1);
neff_data = abs(neff_data.result);
mismatch = neff - neff_data;
}
if ((mismatch(1)*mismatch(end)) <=0) {
idx_match = find(abs(mismatch) == min(abs(mismatch)));
itn = max_itn + 1;
}
else {
delta_match = mismatch(1) - mismatch(end);
cent_match = (mismatch(1) + mismatch(end))/2;
delta_width = (width_delta(1)-width_delta(end))/delta_match*cent_match;
width_cur = width_cur - delta_width;
width_cur = round(width_cur/width_step)*width_step;
print(width_cur);
}
}
#matched_width = width_sweep(idx_match);
return width_sweep(idx_match);
load(cur_file_name);
}
simulation/Lumerical/mx_devices_lib.lsf
+274
View File
@@ -0,0 +1,274 @@
function mx_euler_ring(name,coord,euler_para,wafer)
{
R1 = euler_para.R1;
R0 = euler_para.R0;
w1 = euler_para.w1;
w0 = euler_para.w0;
para = euler_para.para;
## setting the ring to a group ##
addstructuregroup;
set('name',name);
set('x',0);
set('y',0);
set('z',0);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[ 0,0,0],'single','linear',wafer,[0,0]);
delete;
sz = wg.sz;
wg = mx_euler_wg2wg(euler_para,pi/2,0,[0,-sz(2),0],'single','linear',wafer,[0,0]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[0,-sz(2),0],'single','linear',wafer,[1,0]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[0, sz(2),0],'single','linear',wafer,[0,1]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[0, sz(2),0],'single','linear',wafer,[1,1]);
addtogroup(name);
select(name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
sz = [sz(1)*2,sz(2)*2];
ring = struct;
ring.sz = sz;
ring.w = wg.w;
return ring;
}
## =================================================== ##
## DEVICE: ring coupler with euler bend attached
## =================================================== ##
function mx_euler_racetrack(name,coord,euler_para,dLx,dLy,wafer)
{
R1 = euler_para.R1;
R0 = euler_para.R0;
w1 = euler_para.w1;
w0 = euler_para.w0;
para = euler_para.para;
## generation of the single racetrack ##
## setting the ring to a group ##
addstructuregroup;
set('name',name);
set('x',0);
set('y',0);
set('z',0);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[ dLx/2,-dLy/2,0],'dual','linear',wafer,[0,0]);
delete;
sz = wg.sz;
wg = mx_euler_wg2wg(euler_para,pi/2,0,[ dLx/2,-dLy/2-sz(2),0],'dual','linear',wafer,[0,0]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[-dLx/2,-dLy/2-sz(2),0],'dual','linear',wafer,[1,0]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[ dLx/2, dLy/2+sz(2),0],'dual','linear',wafer,[0,1]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,pi/2,0,[-dLx/2, dLy/2+sz(2),0],'dual','linear',wafer,[1,1]);
dy = sz(2);
dx = sz(1);
addtogroup(name);
mx_rect('wg_d',[0,-dLy/2-dy,0],[dLx+1e-9,w0,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_rect('wg_u',[0, dLy/2+dy,0],[dLx+1e-9,w0,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_rect('wg_l',[-dLx/2-dx,0,0],[w1,dLy+1e-9,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_rect('wg_r',[ dLx/2+dx,0,0],[w1,dLy+1e-9,H_wafer],wafer.Material,1,0);
addtogroup(name);
select(name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
sz = [dLx+2*dx,dLy+2*dy];
racetrack = struct;
racetrack.sz = sz;
racetrack.w = wg.w;
return racetrack;
}
## =================================================== ##
## DEVICE: ring coupler with euler bend attached
## =================================================== ##
function mx_euler_coupler(name,coord,coupler_para,dLc,dAc,Att,coupler_type,H_wafer,mWafer){
w_cp = coupler_para.w_cp;
R_cp = coupler_para.R_cp;
Ratt = coupler_para.Ratt;
Rmin = coupler_para.Rmin;
w_wg = coupler_para.w_wg;
para = coupler_para.para;
addstructuregroup;
set('name',name);
set('x',0);
set('y',0);
set('z',0);
if (coupler_type=='straight' or coupler_type=='s' or coupler_type=='DC'){
mx_rect('wg_coupling',[0,0,0],[dLc,w_cp,H_wafer],mWafer,1,0);
addtogroup(name);
dx_attach = dLc/2;
dy_attach = 0;
Acp = 0;
}
else if (coupler_type=='bend' or coupler_type=='b' or coupler_type=='BDC'){
if (dAc>0){
mx_ring('wg_coupling',[0,R_cp,0],H_wafer,[R_cp-w_cp/2,R_cp+w_cp/2],[270-dAc/2/pi*180,270+dAc/2/pi*180],mWafer,1,0);
addtogroup(name);
}
Acp = dAc/2;
dx_attach = R_cp*sin(Acp);
dy_attach = R_cp-R_cp*cos(Acp);
}
else {
Acp = 0;
dx_attach = 0;
dy_attach = 0;
}
euler_para = struct;
euler_para.R0 = R_cp;
euler_para.R1 = Ratt;
euler_para.w0 = w_cp;
euler_para.w1 = w_cp;
euler_para.para = para;
euler_para.order = coupler_para.order;
euler_para.w_offset = coupler_para.w_offset;
wg = mx_euler_wg2wg(euler_para,Att,Acp,[dx_attach,dy_attach,0],'single','linear',H_wafer,mWafer,[0,0]);
addtogroup(name);
wg = mx_euler_wg2wg(euler_para,Att,Acp,[-dx_attach,dy_attach,0],'single','linear',H_wafer,mWafer,[1,0]);
addtogroup(name);
euler_para.R0 = Ratt;
euler_para.R1 = Rmin;
euler_para.R2 = Ratt;
euler_para.w0 = w_cp;
euler_para.w1 = w_wg;
sz = wg.sz;
mx_euler_wg2wg(euler_para,-Att-Acp,Att+Acp,[-dx_attach-sz(1),dy_attach+sz(2),0],'dual','linear',H_wafer,mWafer,[1,0]);
addtogroup(name);
wg_attach = mx_euler_wg2wg(euler_para,-Att-Acp,Att+Acp,[ dx_attach+sz(1),dy_attach+sz(2),0],'dual','linear',H_wafer,mWafer,[0,0]);
addtogroup(name);
mx_rect('patch',[0,0,0],[1e-9,w_cp,H_wafer],mWafer,1,0);
addtogroup(name);
sz_attach = wg_attach.sz;
select(name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
cp_sz = [sz_attach(1)*2+dx_attach*2+sz(1)*2,sz_attach(2)+dy_attach+sz(2)];
return cp_sz;
}
## =================================================== ##
## DEVICE: ring coupler with circular bend attached
## =================================================== ##
function mx_circular_coupler(name,coord,w_couple,R_couple,dAc,Att,wafer)
{
addstructuregroup;
set('name',name);
set('x',0);
set('y',0);
set('z',0);
mx_ring('wg_coupling',[0,R_couple,0],H_wafer,[R_couple-w_couple/2,R_couple+w_couple/2],[270-dAc/2/pi*180,270+dAc/2/pi*180],wafer.Material,1,0);
addtogroup(name);
mx_ring('wg_in',[R_couple*sin(dAc/2)*2,R_couple*(1-cos(dAc/2)*2),0],H_wafer,[R_couple-w_couple/2,R_couple+w_couple/2],[90,90+dAc/2/pi*180],wafer.Material,1,0);
addtogroup(name);
mx_ring('wg_out',[-R_couple*sin(dAc/2)*2,R_couple*(1-cos(dAc/2)*2),0],H_wafer,[R_couple-w_couple/2,R_couple+w_couple/2],[90-dAc/2/pi*180,90],wafer.Material,1,0);
addtogroup(name);
select(name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
cp_sz = [R_couple*(sin(dAc/2))*2*2,R_couple*(1-cos(dAc/2))*2];
return cp_sz;
}
function mx_std_dc(name,coord,gap,w_cp,L_cp,L_attach,w_wg,R0,A,wafer)
{
addstructuregroup;
set('name',name);
set('x',0);
set('y',0);
set('z',0);
Lt = abs(w_wg-w_cp)/tan(5/180*pi);
taper_vtx_x = [0,0,-Lt,-Lt];
taper_vtx_y = [w_cp/2,-w_cp/2,-w_wg/2,w_wg/2];
taper_vtx = [taper_vtx_x;taper_vtx_y];
mx_rect('cp_u',[0,w_cp/2+gap/2,0],[L_cp,w_cp,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_rect('cp_d',[0,-(w_cp/2+gap/2),0],[L_cp,w_cp,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_ul',[-L_cp/2,(w_cp/2+gap/2)+R0,0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[270-A,270],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_ul',[-L_cp/2-sin(A/180*pi)*R0*2,R0+(w_cp/2+gap/2)-cos(A/180*pi)*R0*2,0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[90-A,90],wafer.Material,1,0);
addtogroup(name);
y_port = R0+(w_cp/2+gap/2)-cos(A/180*pi)*R0*2+R0;
x_port = -L_cp/2-sin(A/180*pi)*R0*2-L_attach/2-Lt;
mx_poly('ul_taper',[-L_cp/2-sin(A/180*pi)*R0*2,y_port,0],taper_vtx,H_wafer,wafer.Material,1,0);
addtogroup(name);
mx_rect('ul_attach',[x_port,y_port,0],[L_attach,w_wg,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_dl',[-L_cp/2,-((w_cp/2+gap/2)+R0),0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[90,90+A],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_dl',[-L_cp/2-sin(A/180*pi)*R0*2,-(R0+(w_cp/2+gap/2)-cos(A/180*pi)*R0*2),0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[270,270+A],wafer.Material,1,0);
addtogroup(name);
mx_poly('dl_taper',[-L_cp/2-sin(A/180*pi)*R0*2,-y_port,0],taper_vtx,H_wafer,wafer.Material,1,0);
addtogroup(name);
mx_rect('dl_attach',[x_port,-y_port,0],[L_attach,w_wg,H_wafer],wafer.Material,1,0);
addtogroup(name);
taper_vtx(1,:) = -taper_vtx(1,:);
mx_ring('cp_ur',[L_cp/2,(w_cp/2+gap/2)+R0,0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[270,270+A],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_ur',[L_cp/2+sin(A/180*pi)*R0*2,R0+(w_cp/2+gap/2)-cos(A/180*pi)*R0*2,0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[90,90+A],wafer.Material,1,0);
addtogroup(name);
mx_poly('ur_taper',[-(-L_cp/2-sin(A/180*pi)*R0*2),y_port,0],taper_vtx,H_wafer,wafer.Material,1,0);
addtogroup(name);
mx_rect('ur_attach',[-x_port,y_port,0],[L_attach,w_wg,H_wafer],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_dr',[L_cp/2,-((w_cp/2+gap/2)+R0),0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[90-A,90],wafer.Material,1,0);
addtogroup(name);
mx_ring('cp_dr',[L_cp/2+sin(A/180*pi)*R0*2,-(R0+(w_cp/2+gap/2)-cos(A/180*pi)*R0*2),0],H_wafer,[R0-w_cp/2,R0+w_cp/2],[270-A,270],wafer.Material,1,0);
addtogroup(name);
mx_poly('dr_taper',[-(-L_cp/2-sin(A/180*pi)*R0*2),-y_port,0],taper_vtx,H_wafer,wafer.Material,1,0);
addtogroup(name);
mx_rect('dr_attach',[-x_port,-y_port,0],[L_attach,w_wg,H_wafer],wafer.Material,1,0);
addtogroup(name);
sz = [abs(x_port-L_attach/2)*2,y_port*2];
return sz;
}
simulation/Lumerical/mx_frames_lib.lsf
+56
View File
@@ -0,0 +1,56 @@
##### FUNCTION LIB #####
function mx_FDE_dual_strip(wafer,w1,w2,gap){
cladding = wafer.cladding;
mx_rect('WG_inner',[-w1/2-gap/2,0,0],[w1,10e-6,wafer.Height],wafer.Material,1,0);
mx_rect('WG_outer',[w2/2+gap/2,0,0],[w2,10e-6,wafer.Height],wafer.Material,1,0);
if (wafer.clad_on){
mx_rect('SiO2',[0,0,0],[cladding.Size*2+w1+w2+gap,cladding.Size,cladding.Height],cladding.Material,2,0);
}
else {
mx_rect('SiO2',[0,0,-cladding.Height/2-wafer.Height/2],[cladding.Size*2+w1+w2+gap,cladding.Size,cladding.Height],cladding.Material,2,0);
}
#inner = wl+gap;
#outer = w2+gap;
#return [inner,outer];
}
function mx_FDE_strip(wafer,w){
cladding = wafer.cladding;
mx_rect('WG',[0,0,0],[w,10e-6,wafer.Height],wafer.Material,1,0);
if (wafer.slab>=1e-10) {
mx_rect('slab',[0,0,-wafer.Height/2+wafer.slab/2],[cladding.Size*2+w,cladding.Size,wafer.slab],wafer.Material,1,0);
}
if (wafer.clad_on){
mx_rect('SiO2',[0,0,0],[cladding.Size*2+w,cladding.Size,cladding.Height],cladding.Material,2,0);
}
else {
mx_rect('SiO2',[0,0,-cladding.Height/2-wafer.Height/2],[cladding.Size*2+w,cladding.Size,cladding.Height],cladding.Material,2,0);
}
#inner = wl+gap;
#outer = w2+gap;
#return [inner,outer];
}
##### FUNCTION LIB #####
function mx_FDE_Disk(wafer,R){
cladding = wafer.cladding;
mx_rect('Disk',[-R,0,0],[R*2,10e-6,wafer.Height],wafer.Material,1,0);
if (wafer.clad_on){
mx_rect('SiO2',[0,0,0],[cladding.Size*2+R,cladding.Size,cladding.Height],cladding.Material,2,0);
}
else {
mx_rect('SiO2',[0,0,-cladding.Height/2-wafer.Height/2],[cladding.Size*2+R,cladding.Size,cladding.Height],cladding.Material,2,0);
}
#inner = wl+gap;
#outer = w2+gap;
#return [inner,outer];
}
simulation/Lumerical/mx_function_lib.lsf
+105
View File
@@ -0,0 +1,105 @@
##### maxwell lib #####
##### Function lib ####
function get_system_time()
{
fname="cur_time.txt"; # file name to store current time
cmd="echo %date:~0,4%%date:~5,2%%date:~8,2%_%time:~0,2%%time:~3,2%%time:~6,2%> "+fname; # system command to get current time and write to fname
system(cmd); # run command to get time and save to file
cur_time=read(fname); # read time from file
cur_time = substring(cur_time,1,15);
return cur_time;
}
function mode_polar_select(polar_name,current_mode_name){
if (polar_name=='TE') {
polar_select = 0.7;
}
else if (polar_name=='TM') {
polar_select = -0.3;
}
cur_pol = getresult(current_mode_name,'TE polarization fraction');
selected = ((cur_pol*sign(polar_select))>polar_select);
return selected;
}
function mx_get_sys_time(){
system("notepad");
fname="cur_time.txt"; # file name to store current time
cmd="echo %time% "+fname; # system command to get current time and write to fname
rm(fname); # delete time file
system(cmd); # run command to get time and save to file
cur_time=read(fname); # read time from file
return cur_time;
}
#### @ result : {'neff','loss'} cell arrays #####
function mx_get_mode_data(center_wl,mode_pol,mode_idx,wg_bend,results){
run;
setanalysis('use max index',1);
setanalysis('number of trial modes',20);
setanalysis('wavelength',center_wl);
if (wg_bend==0) {
setanalysis('bent waveguide',0);
}
else if (wg_bend>0) {
setanalysis('bent waveguide',1);
setanalysis('bend radius',wg_bend);
setanalysis('bend orientation',90);
}
else {
setanalysis('bent waveguide',1);
setanalysis('bend radius',abs(wg_bend));
setanalysis('bend orientation',-90);
}
n_modes = findmodes;
idx_TE = 0;
idx_TM = 0;
idx_final = 0;
for (idx_n=1;idx_n<=n_modes;idx_n=idx_n+1){
cur_mode_name = 'FDE::data::mode'+num2str(idx_n);
if (mode_polar_select('TE',cur_mode_name)){
idx_TE = idx_TE+1;
if (idx_TE==(mode_idx+1) & (mode_pol == 'TE')){
idx_final = idx_n;
idx_n = n_modes +1 ;
}
}
if (mode_polar_select('TM',cur_mode_name)){
idx_TM = idx_TM+1;
if (idx_TM==(mode_idx+1) & (mode_pol == 'TM')){
idx_final = idx_n;
idx_n = n_modes +1 ;
}
}
}
final_data = struct;
final_mode_name = 'FDE::data::mode'+num2str(idx_final);
for (idx_result=1;idx_result<=length(results);idx_result = idx_result+1){
temp = getdata(final_mode_name,results{idx_result});
ins = 'final_data.'+results{idx_result}+ '=temp;';
eval(ins);
}
return final_data;
}
simulation/Lumerical/mx_lib_install.lsf
+27
View File
@@ -0,0 +1,27 @@
#### Lib Install ####
PATH_LIB = ABSOLUTE_LIB_DIR;
NAME_LIB_1 = 'mx_structures_lib.lsf';
feval(PATH_LIB+NAME_LIB_1);
NAME_LIB_2 = 'mx_simulation_lib.lsf';
feval(PATH_LIB+NAME_LIB_2);
NAME_LIB_3 = 'mx_function_lib.lsf';
feval(PATH_LIB+NAME_LIB_3);
NAME_LIB_4 = 'mx_analysis_lib.lsf';
feval(PATH_LIB+NAME_LIB_4);
NAME_LIB_5 = 'mx_frames_lib.lsf';
feval(PATH_LIB+NAME_LIB_5);
NAME_LIB_6 = 'mx_poly_spiral_lib.lsf';
feval(PATH_LIB+NAME_LIB_6);
NAME_LIB_7 = 'mx_devices_lib.lsf';
feval(PATH_LIB+NAME_LIB_7);
NAME_LIB = 'GDS_SIMU_DEVICE_2X2.lsf';
feval(PATH_LIB+NAME_LIB);
simulation/Lumerical/mx_poly_spiral_lib.lsf
+265
View File
@@ -0,0 +1,265 @@
## Generate a spiral line ##
function mx_poly_spiral(r,theta,coord,order,para){
#UNTITLED2 Summary of this function goes here
# Detailed explanation goes here
dL = para.dL;
r_init = r(1);
r_end = r(2);
theta_init = theta(1);
theta_end = theta(2);
x_init = coord(1);
y_init = coord(2);
K0 = 1/r_init;
K1 = 1/r_end;
L0 = abs(theta_end - theta_init)/(K0+(K1-K0)*order/(order+1));
L = [0:dL:L0];
K = K0 + (K1 - K0)/L0^order * (L0^order - abs(L-L0)^order);
R = 1/K;
R = (R<=para.R_max)*R + (R>para.R_max)*para.R_max*ones(length(R),1);
direction = sign(theta_end-theta_init);
dt = direction*dL/R;
#theta_temp = cumsum(dt)+theta_init;
theta_temp = dt;
x=zeros(length(L),1)+x_init;
y=zeros(length(L),1)+y_init;
for (i=2;i<=length(L);i=i+1){
theta_temp(i) = theta_temp(i)+theta_temp(i-1);
cur_theta = theta_temp(i)+theta_init;
pre_theta = theta_temp(i-1)+theta_init;
x(i) = x(i-1) + direction* R(i)*( sin( cur_theta ) - sin(pre_theta ) );
y(i) = y(i-1) - direction* R(i)*( cos( cur_theta ) - cos( pre_theta ) );
}
theta_temp = [theta_temp(1);theta_temp(2:50:end-1);theta_temp(end)]+theta_init;
x = [x(1);x(2:50:end-1);x(end)];
y = [y(1);y(2:50:end-1);y(end)];
vtx = [x,y,theta_temp];
return vtx;
}
function mx_wg_draw(vtx,width){
#UNTITLED6 Summary of this function goes here
# Detailed explanation goes here
z = vtx(:,1) + 1i*vtx(:,2); # complex points
#dz = diff(z); # direction of each point
dz = z(2:end) - z(1:end-1);
dz = [transpose(dz),dz(end)];
dir_upper = -1i*real(dz)+imag(dz);
dir_down = 1i*real(dz)-imag(dz);
p_upper = [z + dir_upper*width/2/abs(dir_upper)];
p_down = [z+ dir_down*width/2/abs(dir_down)];
wg = struct;
wg.curve_inner = [real(p_upper),imag(p_upper)];
wg.curve_outer = [real(p_down),imag(p_down)];
return wg;
}
function mx_euler_wg(vtx,width,offset){
#UNTITLED6 Summary of this function goes here
# Detailed explanation goes here
z = vtx(:,1) + 1i*vtx(:,2); # complex points
#dz = diff(z); # direction of each point
dz = sin(vtx(:,3))*1i + cos(vtx(:,3));
dz = [transpose(dz)];
dir_upper = -1i*real(dz)+imag(dz);
dir_down = 1i*real(dz)-imag(dz);
p_upper = [z + dir_upper*(offset+width/2)/abs(dir_upper)];
p_down = [z+ dir_down*(-offset+width/2)/abs(dir_down)];
wg = struct;
wg.curve_inner = [real(p_upper),imag(p_upper)];
wg.curve_outer = [real(p_down),imag(p_down)];
return wg;
}
function mx_euler_wg2wg(euler_para,bend_angle,theta_start,coord,bend_type,width_type,Height,Material,vtx_flip)
{
R0 = euler_para.R0;
R1 = euler_para.R1;
Win = euler_para.w0;
dW = euler_para.w1 - euler_para.w0;
order = euler_para.order;
if (bend_type=='single'){
vtx_start = mx_poly_spiral([R0,R1],[theta_start,bend_angle+theta_start],[0,0],order,euler_para.para);
p_start = vtx_start(1,:);
p_end = vtx_start(end,:);
vtx_euler_bend = vtx_start;
}
else {
R2 = euler_para.R2;
vtx_start = mx_poly_spiral([R0,R1],[theta_start,bend_angle/2+theta_start],[0,0],order,euler_para.para);
vtx_stop = mx_poly_spiral([R1,R2],[bend_angle/2+theta_start,bend_angle+theta_start],[vtx_start(end,1),vtx_start(end,2)],order,euler_para.para);
p_start = vtx_start(1,:);
p_end = vtx_stop(end,:);
vtx_euler_bend = [vtx_start;vtx_stop(2:end,:)] ;
}
## attaching waveguide
dx = abs(p_end(2) - p_start(1));## displacement in x direction
dL = (vtx_euler_bend(2:end,2) - vtx_euler_bend(1:end-1,2))^2 + (vtx_euler_bend(2:end,1) - vtx_euler_bend(1:end-1,1))^2;
dL = sqrt(dL);
##L = cumsum(dL) ## L for each pieces
L = zeros(length(dL),1);
L(1) = dL(1);
for (idx=2;idx<=length(L);idx=idx+1){
L(idx) = L(idx-1)+dL(idx);
}
L = [0;L];
L0 = sum(dL);
w_offset = 0;
if (width_type=='cos'){## in this situation, dW is the difference of input and output
dy = abs(p_end(2) - p_start(2)); ## displacement in y direction
vtx_euler_bend(:,2) = -dy + vtx_euler_bend(:,2);
z = vtx_euler_bend(:,3);
#z = vtx_euler_bend(:,1) + 1i*vtx_euler_bend(:,2);
w = dW/2*cos(z*pi/abs(bend_angle)) + (Win*2+dW)/2;
}
else if (width_type=='sin'){ ## in this situation, win = wout, dW is the middle width difference
if (abs(bend_angle-pi)<0.001){
dy = abs(vtx_start(end,2) - vtx_start(1,2)); ## displacement in y direction
}
else {
dy = abs(p_end(2) - p_start(2)); ## displacement in y direction
}
vtx_euler_bend(:,2) = -dy + vtx_euler_bend(:,2);
z = vtx_euler_bend(:,3);
w = dW*cos(z+pi/2)^2 + Win; ## revised 2023.03.27
vtx_euler_bend(:,2) = dy + vtx_euler_bend(:,2);
}
else if (width_type=='pumpkin'){ ## in this situation, win = wout, dW is the middle width difference
if (abs(bend_angle-pi)<0.001){
dy = abs(vtx_start(end,2) - vtx_start(1,2)); ## displacement in y direction
}
else {
dy = abs(p_end(2) - p_start(2)); ## displacement in y direction
}
vtx_euler_bend(:,2) = -dy + vtx_euler_bend(:,2);
z = vtx_euler_bend(:,3);
z = z;
z = z^0.5*(pi/2)^0.5;
z = sin(z)^2*pi/2;
w = dW*sin( z )^2 + Win; ## revised 2023.05.04
#w = dW*sin( z )^2 + Win; ## revised 2023.05.04
#w = dW*theta/(pi/2) + Win; ## revised 2023.05.04
vtx_euler_bend(:,2) = dy + vtx_euler_bend(:,2);
}
else if (width_type=='special'){ ## in this situation, win = wout, dW is the middle width difference
if (abs(bend_angle-pi)<0.001){
dy = abs(vtx_start(end,2) - vtx_start(1,2)); ## displacement in y direction
}
else {
dy = abs(p_end(2) - p_start(2)); ## displacement in y direction
}
vtx_euler_bend(:,2) = -dy + vtx_euler_bend(:,2);
z = vtx_euler_bend(:,3);
z = z;
z = z^0.65*(pi/2)^0.35;
z = sin(z)^2*pi/2;
w = dW*sin( z )^2 + Win; ## revised 2023.05.04
vtx_euler_bend(:,2) = dy + vtx_euler_bend(:,2);
}
else if (width_type=='sin2'){ ## in this situation, win = wout, dW is the middle width difference
if (abs(bend_angle-pi)<0.001){
dy = abs(vtx_start(end,2) - vtx_start(1,2)); ## displacement in y direction
}
else {
dy = abs(p_end(2) - p_start(2)); ## displacement in y direction
}
vtx_euler_bend(:,2) = -dy + vtx_euler_bend(:,2);
z = vtx_euler_bend(:,1) + 1i*vtx_euler_bend(:,2);
w = dW/2*sin(angle(z)*2+abs(bend_angle))^2 + Win+dW/2;
}
else if (width_type=='linear'){
w = dW/L0*L + Win;}
else if (width_type=='dual_linear'){
w = dW/2/(L0/2)*abs(L-L0/2) + Win+dW/2;}
else if (width_type=='linear_offset'){
w = dW/L0*L + Win;
w_offset = euler_para.w_offset;
}
else { ## default linear from input to output
w = dW/L0*L + Win;}
sz = abs([p_end(1) - p_start(1),p_end(2) - p_start(2)]); ## the size of the bending
wg = mx_euler_wg(vtx_euler_bend,w,w_offset);
vtx = [wg.curve_outer;flip(wg.curve_inner,1)];
if (vtx_flip(1)==1){
vtx(:,1) = -vtx(:,1);}
if (vtx_flip(2)==1){
vtx(:,2) = -vtx(:,2);}
mx_poly('euler',coord,vtx,Height,Material,1,0);
wg = struct;
wg.sz = sz;
wg.w = w;
wg.vtx = vtx_euler_bend; ## central line
z = vtx(:,1) + 1i*vtx(:,2); # complex points
#dz = diff(z); # direction of each point
dz = z(2:end) - z(1:end-1);
dz = [transpose(dz),dz(end)];
dir_upper = -1i*real(dz)+imag(dz);
dir_down = 1i*real(dz)-imag(dz);
wg.angle = -angle(dir_upper);
return wg;
}
simulation/Lumerical/mx_simulation_lib.lsf
+207
View File
@@ -0,0 +1,207 @@
## @ cord = [x,y,z] denotes a rectangle
## @ cord_span = [xs,ys,zs] denotes a rectangle
function mx_simu_area(name,coord,span,mesh_accuracy,meshs,boundary,time) {
if((name=='FDTD')){
addfdtd;
set('simulation time',time*1e-15);
FDE_on = 0;
}
else if ((name=='FDE_x')){
FDE_on = 1;
addfde;
set('solver type','2D X normal');
span(1) = 0;
}
else if (name=='FDE_y'){
addfde;
FDE_on = 1;
set('solver type','2D Y normal');
span(2) = 0;
}
else if (name=='FDE_z'){
addfde;
FDE_on = 1;
set('solver type','2D Z normal');
span(3) = 0;
}
x = coord(1);
y = coord(2);
z = coord(3);
set('x',x);
set('y',y);
set('z',z);
xs = span(1);
ys = span(2);
zs = span(3);
if (xs>0) {
set('x span',xs);
set('x min bc',boundary);
set('x max bc',boundary);
if (FDE_on) {
set('define x mesh by','maximum mesh step');
set('dx',meshs(1));
}
}
if (ys>0) {
set('y span',ys);
set('y min bc',boundary);
set('y max bc',boundary);
if (FDE_on) {
set('define y mesh by','maximum mesh step');
set('dz',meshs(2));
}
}
if (zs>0) {
set('z span',zs);
set('z min bc',boundary);
set('z max bc',boundary);
if (FDE_on) {
set('define z mesh by','maximum mesh step');
set('dz',meshs(3));
}
}
if((name=='FDTD')){
if (mesh_accuracy==0){
addmesh;
set('dx',meshs(1));
set('dy',meshs(2));
set('dz',meshs(3));
set('x',x);
set('y',y);
set('z',z);
xs = span(1);
ys = span(2);
zs = span(3);
set('x span',xs);
set('y span',ys);
set('z span',zs);
}
else {
set('mesh accuracy',mesh_accuracy);
}
}
}
##
function mx_mode_source(name,coord,span,s_dir,theta,bend,mode_idx,wl){
addmode;
set('name',name);
set('injection axis',abs(s_dir));
set('direction',1.5-sign(s_dir)/2);
x = coord(1);
y = coord(2);
z = coord(3);
set('x',x);
set('y',y);
set('z',z);
xs = span(1)*((abs(s_dir))~=1);
ys = span(2)*((abs(s_dir))~=2);
zs = span(3)*((abs(s_dir))~=3);
if (xs>0) {
set('x span',xs);
}
if (ys>0) {
set('y span',ys);
}
if (zs>0) {
set('z span',zs);
}
if (bend(1)>0){
set('bent waveguide',1);
set('bend orientation',bend(2));
set('bend radius',bend(1));
}
else{
set('bent waveguide',0);
}
set('theta',theta);
set('theta',theta);
set('mode selection','user select');
set('wavelength start',wl(1));
set('wavelength stop',wl(2));
updatesourcemode(mode_idx);
}
##
function mx_mode_expansion(name,coord,span,m_dir,theta,bend,mode_idx,wl,monitor_name){
addmodeexpansion;
set('name',name);
set('monitor type',abs(m_dir));
x = coord(1);
y = coord(2);
z = coord(3);
set('x',x);
set('y',y);
set('z',z);
xs = span(1)*((abs(m_dir))~=1);
ys = span(2)*((abs(m_dir))~=2);
zs = span(3)*((abs(m_dir))~=3);
if (xs>0) {
set('x span',xs);
}
if (ys>0) {
set('y span',ys);
}
if (zs>0) {
set('z span',zs);
}
if (bend(1)>0){
set('bent waveguide',1);
set('bend orientation',bend(2));
set('bend radius',bend(1));
}
else{
set('bent waveguide',0);
}
set('theta',theta);
set('mode selection','user select');
updatemodes(mode_idx);
setexpansion('input',monitor_name);
}
simulation/Lumerical/mx_structures_lib.lsf
+205
View File
@@ -0,0 +1,205 @@
function mx_rect(name,coord,sz,material,mesh_order,refractive_index)
{
addrect;
set('name',name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
set('x span',sz(1));
set('y span',sz(2));
set('z span',sz(3));
set('material',material);
set('override mesh order from material database',1);
set('mesh order',mesh_order);
if (refractive_index>0)
{
set('material','<Object defined dielectric>');
set('index',refractive_index);
}
}
function mx_concoid(name,coord,height,R0,T0,kR,w0,res,theta,material,mesh_order,refractive_index)
{
## in polar axis
dT = linspace(T0,theta+T0,res);
R = ((dT-T0)*kR+R0);
e_theta = -1/((R0/kR)+dT-T0);
e_rou = ones(length(dT));
e_theta(end) = 0;
e_theta(1) = 0 ;
ex = cos(dT)*e_rou - sin(dT)*e_theta;
ey = sin(dT)*e_rou + cos(dT)*e_theta ;
Lnorm = sqrt(ex^2+ey^2);
vtx_x = R*cos(dT);
vtx_y = R*sin(dT);
vtx_out_x = vtx_x + w0/2*ex/Lnorm;
vtx_out_y = vtx_y + w0/2*ey/Lnorm;
vtx_in_x = vtx_x - w0/2*ex/Lnorm;
vtx_in_y = vtx_y - w0/2*ey/Lnorm ;
vtx_in = [flip(vtx_in_x,1),flip(vtx_in_y,1)];
vtx_out = [vtx_out_x,vtx_out_y];
vtx = [vtx_out;vtx_in];
mx_poly(name,coord,vtx,height,material,mesh_order,refractive_index);
return vtx;
}
function mx_taper(name,coord,height,wa,wb,L,offset,material,mesh_order,refractive_index)
{
vtx_x = [0,L,L,0];
vtx_y = [wa/2,wb/2+offset,-wb/2+offset,-wa/2];
vtx = [vtx_x;vtx_y];
mx_poly(name,coord,vtx,height,material,mesh_order,refractive_index);
return vtx;
}
function mx_ring(name,coord,height,radius,theta,material,mesh_order,refractive_index)
{
addring;
set('name',name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
set('z span',height);
set('outer radius',max(radius));
set('inner radius',min(radius));
set('theta start',theta(1));
set('theta stop',theta(2));
set('material',material);
set('override mesh order from material database',1);
set('mesh order',mesh_order);
if (refractive_index>0)
{
set('material','<Object defined dielectric>');
set('index',refractive_index);
}
}
function mx_ring_coic(name,coord,height,Ra_in,Rb_in,Ra_out,Rb_out,offset,theta,material,mesh_order,refractive_index)
{
theta = linspace(theta(1),theta(2),1001);
xout = Ra_out*cos(theta);
yout = Rb_out*sin(theta);
xin = Ra_in*cos(theta);
yin = Rb_in*sin(theta)+offset;
vtx_outer = [xout,yout];
vtx_inner = [xin,yin];
vtx = [vtx_outer;flip(vtx_inner,1)];
mx_poly(name,coord,vtx,height,material,mesh_order,refractive_index);
return vtx;
}
function mx_poly(name,coord,vtx,height,material,mesh_order,refractive_index)
{
addpoly;
set('name',name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
set('vertices',vtx);
set('z span',height);
set('material',material);
set('override mesh order from material database',1);
set('mesh order',mesh_order);
if (refractive_index>0)
{
set('index',refractive_index);
}
}
function mx_elipse(name,coord,height,La,Lb,wa,wb,theta,offset,material,mesh_order,refractive_index)
{
theta = linspace(theta(1),theta(2),1001);
x = La*cos(theta);
y = Lb*sin(theta);
## norm direction
dX = 2*x/La^2;
dY = 2*y/Lb^2;
L_norm = sqrt(dX^2+dY^2);
offset = (offset(1)-offset(2))*cos(theta)^2 + offset(2);
w = (wa-wb)*cos(theta)^2 + wb; ## width variation
vtx_outer_x = x + dX/L_norm*(w/2+offset);
vtx_outer_y = y + dY/L_norm*(w/2+offset);
vtx_inner_x = x + dX/L_norm*(-w/2+offset);
vtx_inner_y = y + dY/L_norm*(-w/2+offset);
vtx_outer = [vtx_outer_x,vtx_outer_y];
vtx_inner = [vtx_inner_x,vtx_inner_y];
vtx = [vtx_outer;flip(vtx_inner,1)];
mx_poly(name,coord,vtx,height,material,mesh_order,refractive_index);
return vtx;
}
function mx_power_monitor(name,coord,sz,diretion)
{
addpower;
set('name',name);
set('x',coord(1));
set('y',coord(2));
set('z',coord(3));
if (diretion==1)
{
set('monitor type','2D X-normal');
set('y span',sz(2));
set('z span',sz(3));
}
if (diretion==2)
{
set('monitor type','2D Y-normal');
set('x span',sz(1));
set('z span',sz(3));
}
if (diretion==3)
{
set('monitor type','2D Z-normal');
set('x span',sz(1));
set('y span',sz(2));
}
}