光学设计的秘密花园: CCL programming

用CCL实现手工设计Cooke Triplet

Thu, 04 Oct 2007 17:08:42 GMT

　　《透镜设计基础》中第314页到第321页详述了用手工计算的方法设计一个Cooke式三片镜，也就是K. Schwarzschild方法。在以下的内容中，首先演示如何cooke_triplet命令进行Cooke式三片镜的设计，然后讲解如何将这一方法整合到OSLO的环境中。

　　启动OSLO，在lens spreadsheet关闭时按Ctrl+D，出现如下对话框，每一参数的意义请参照《透镜设计基础》中的解释。

　　点选OK，然后在命令行中依照提示依次输入三个镜片的中心厚度，比如0.4，0.25，0.45，分别按回车键确认。这时，当前的OSLO环境中已经生成了一个符合参数要求的Cooke式三片镜，分析图如下。

　　从图中可以看出子午像面过于前倾，可以适当调整一下。将AC的预设值从-0.09调整到-0.06。

　　分析新的镜头，可以看到子午像面不再严重前倾，像散有所改善。

　　讲解如何将这一方法整合到OSLO的环境中。首先打开\private\ccl\a_menu.ccl文件，加入下图中的高亮部分。

　　再打开\private\ccl\a_global.ccl加入下列内容。

double y1 {default(noquery) = 1.111111};

double y2 {default(noquery) = 0.888888};

double y3 {default(noquery) = 0.999999};

double rn1 {default(noquery) = 1.620318};

double vn1 {default(noquery) = 60.31};

double rn2 {default(noquery) = 1.616445};

double vn2 {default(noquery) = 36.62};

double rn3 {default(noquery) = 1.620318};

double vn3 {default(noquery) = 60.31};

double total_efl {default(noquery) = 10};

double lch {default(noquery) = -0.02};

double Petzval {default(noquery) = 0.035};

double K_aim {default(noquery) = 1};

double fie_ang {default(noquery) = 20};

int step {default(noquery) = 500};

double c1_start {default(noquery) = 0.2};

double c1_end {default(noquery) = 0.4};

double SC_target {default(noquery) = -0.08};

double CC_target {default(noquery) = 0.0025};

double AC_target {default(noquery) = -0.09};

double TchC_target {default(noquery) = 0.0};

double Wav1 {default(noquery) = 0.5892938};

double Wav2 {default(noquery) = 0.4861327};

double Wav3 {default(noquery) = 0.6562725};

最后是函数的主体部分，编译后就可以了。

cmd scalecv(int start_surf, int end_surf, float efl)

{

float feedback=1.0;

stp outp off;

int counter;

do{

for(counter=start_surf;counter<end_surf+1;counter++)

cv(counter,cv[counter]*feedback);

feedback=pe_efl(start_surf,end_surf)/efl;

}

while(fabs(feedback-1)>0.00000001);

stp outp on;

}

cmd Gsum ( float refra_index, float result[] )

{

result[0] = 0;

result[1] = refra_index * refra_index * ( refra_index - 1 ) / 2 ;

result[2] = ( 2 * refra_index + 1 ) * ( refra_index - 1 ) / 2 ;

result[3] = ( 3 * refra_index + 1 ) * ( refra_index - 1 ) / 2 ;

result[4] = ( refra_index + 2 ) * ( refra_index - 1 ) / ( 2 * refra_index ) ;

result[5] = 2 * ( refra_index + 1 ) * ( refra_index - 1 ) / refra_index ;

result[6] = ( 3 * refra_index + 2 ) * ( refra_index - 1 ) / ( 2 * refra_index ) ;

result[7] = ( 2 * refra_index + 1 ) * ( refra_index - 1 ) / ( 2 * refra_index );

result[8] = refra_index * ( refra_index - 1 ) / 2;

}

double SC_coef[3];

double CC_coef[3];

double AC_coef[3];

double SC_ap_coef[3];

double CC_ap_coef[3];

double AC_ap_coef[3];

cmd sc_sei(double sc_sei_coef[], double y_para, double u_prime_0, double G_sum[], double curvature, double inv_objdist)

{

//calculate the constant

double temp_coef_for_all;

int ii;

temp_coef_for_all = -1 * y_para * y_para * y_para * y_para / ( u_prime_0 * u_prime_0 );

sc_sei_coef[0] = G_sum[1] * curvature * curvature * curvature;

sc_sei_coef[1] = -1 * G_sum[2] * curvature * curvature;

sc_sei_coef[0] += G_sum[3] * curvature * curvature * inv_objdist;

sc_sei_coef[2] = G_sum[4] * curvature;

sc_sei_coef[1] += -1 * G_sum[5] * curvature * inv_objdist;

sc_sei_coef[0] += G_sum[6] * curvature * inv_objdist * inv_objdist;

for (ii = 0; ii < 3; ii++)

{

sc_sei_coef[ii] *= temp_coef_for_all;

}

cmd cc_sei(double cc_sei_coef[], double y_para, double h_prime_0, double G_sum[], double curvature, double inv_objdist)

{

double temp_coef_for_all;

int ii;

temp_coef_for_all = -1 * y_para * y_para * h_prime_0;

cc_sei_coef[1] = 0.25 * G_sum[5] * curvature;

cc_sei_coef[0] = -1 * G_sum[7] * curvature * inv_objdist;

cc_sei_coef[0] += -1 * G_sum[8] * curvature * curvature;

cc_sei_coef[2] = 0;

for (ii = 0; ii < 3; ii++)

{

cc_sei_coef[ii] *= temp_coef_for_all;

}

cmd ac_sei(double ac_sei_coef[], double h_prime_0, double fl )

{

ac_sei_coef[0] = -0.5 * h_prime_0 * h_prime_0 / fl;

ac_sei_coef[1] = 0;

ac_sei_coef[2] = 0;

}

cmd sc_ap(double ap_shift[], double ap_attached[])

{

for (ii = 0; ii < 3; ii++)

{

ap_shift[ii] = ap_attached[ii];

}

cmd cc_ap(double cc_ap_shift[], double cc_ap_attached[], double sc_ap_attached[], double q_factor, double u_prime_0)

{

for (ii = 0; ii < 3; ii++)

{

cc_ap_shift[ii] = cc_ap_attached[ii] + sc_ap_attached[ii] * q_factor * u_prime_0;

}

cmd ac_ap(double ac_ap_shift[], double ac_ap_attached[], double cc_ap_attached[], double sc_ap_attached[], double q_factor, double u_prime_0)

{

for (ii = 0; ii < 3; ii++)

{

ac_ap_shift[ii] = ac_ap_attached[ii] + cc_ap_attached[ii] * 2 * q_factor / u_prime_0 + sc_ap_attached[ii] * q_factor * q_factor;

}

cmd cooke_triplet(double y1, double y2, double y3, double wav1, double wav2, double wav3, double rn1, double vn1, double rn2, double vn2,

double rn3, double vn3, double total_efl, double SC_target, double CC_target, double AC_target,

double Petzval, double lch, double TchC_target, double K_aim, double fie_ang, double c1_start, double c1_end, int step)

{

stp outp off;

double phi[3];

double y[3];

y[0] = y1; y[1] = y2; y[2] = y3;

double v[3];

v[0] = vn1; v[1] = vn2; v[2] = vn3;

double n[3];

n[0] = rn1; n[1] = rn2; n[2] = rn3;

double phi_total;

phi_total = 1/total_efl;

static double u0_obj = 0, u0_ims;

u0_ims = y1/total_efl;

double ptz;

ptz=Petzval;

double coef_phi[3][3], verctor_aber[3];

double ua, ub, uc;

ua=u0_obj;

double airspace_1, airspace_2;

double K;

double k_new, delta_yb, delta_yc;

double upr[4], ypr[3];

upr[0] = tan(-1*fie_ang*dr);

double TchC[3];

double TchC_total, TchC_total_new, TchC_aim;

TchC_aim = TchC_target;

for ( ii = 0, TchC_total = -0.02, delta_yc = 0.01, k = 0.5, delta_yb = 0.01 ; ii < 200; ii++)

{

y[2] += delta_yc;

for ( jj = 0; jj < 200; jj++)

{

y[1] += delta_yb;

for ( i = 0; i < 3; i++) coef_phi[0][i] = y[i];

for ( i = 0; i < 3; i++) coef_phi[1][i] = y[i] * y[i] / v[i];

for ( i = 0; i < 3; i++) coef_phi[2][i] = 1 / n[i];

verctor_aber[0] = y[0] * phi_total;

verctor_aber[1] = -1 * lch * u0_ims * u0_ims;

verctor_aber[2] = Ptz;

slveqs( coef_phi, phi, verctor_aber);

/////////////////////////

//ub uc is at object-side

/////////////////////////

ub = ua + y[0] * phi[0];

uc = ub + y[1] * phi[1];

airspace_1 = ( y[0] -y[1]) / ub;

airspace_2 = ( y[1] -y[2]) / uc;

K_new = airspace_1 / airspace_2;

if ( fabs( K_new - K_aim ) < 0.000001 ) break;

delta_yb = ( K_aim - K_new ) * delta_yb / ( K_new - K );

k = k_new;

}

ypr[0] = airspace_1 * upr[0] / ( 1 - airspace_1 * phi[0] ); ypr[1] = 0; ypr[2] = -1 * ypr[0] / k_new;

upr[1]= upr[0] + ypr[0] * phi[0];

upr[2]= upr[1] + ypr[1] * phi[1];

upr[3]= upr[2] + ypr[2] * phi[2];

TchC[0] = ( -1 * y[0] * ypr[0] * phi[0] ) / ( V[0] * u0_ims);

TchC[1] = 0;

TchC[2] = ( -1 * y[2] * ypr[2] * phi[2] ) / ( V[2] * u0_ims);

TchC_total_new = TchC[0] + TchC[1] + TchC[2];

if ( fabs( TchC_total_new - TchC_aim ) < 0.000001 ) break;

delta_yc = ( TchC_aim - TchC_total_new ) * delta_yc /( TchC_total_new - TchC_total );

TchC_total = TchC_total_new;

}

int lensID;

double g_coef[9];

double sc_coef[3][3];

double cc_coef[3][3];

double ac_coef[3][3];

double sc_ap_coef[3][3];

double cc_ap_coef[3][3];

double ac_ap_coef[3][3];

double temp_sc_coef[3];

double temp_cc_coef[3];

double temp_ac_coef[3];

double temp_sc_ap_coef[3];

double temp_cc_ap_coef[3];

double temp_ac_ap_coef[3];

double u0_=u0_ims;

double c[3];

c[0] = phi[0]/(n[0]-1);

c[1] = phi[1]/(n[1]-1);

c[2] = phi[2]/(n[2]-1);

double inv[3];

inv[0] = ua/y[0];

inv[1] = ub/y[1];

inv[2] = uc/y[2];

double h0_;

h0_= (ypr[2]-upr[3]*(y[2]/(uc+y[2]*phi[2])));

double q[3];

q[0] = ypr[0]/y[0];

q[1] = ypr[1]/y[1];

q[2] = ypr[2]/y[2];

for (lensID=0; lensID<3; lensID++)

{

gsum(n[lensID], g_coef);

//for(i=1; i<9; i++) prt g_coef[i];

//prt "=============================";

sc_sei(temp_sc_coef, y[lensID], u0_, g_coef, c[lensID], inv[lensID]);

for(i=0; i<3; i++)

{

sc_coef[i][lensID]=temp_sc_coef[i];

//aprt sc_coef[i][lensID];

};

//prt;

cc_sei(temp_cc_coef, y[lensID], h0_, g_coef, c[lensID], inv[lensID]);

for(i=0; i<3; i++)

{

cc_coef[i][lensID]=temp_cc_coef[i];

//aprt cc_coef[i][lensID];

};

//prt;

ac_sei(temp_ac_coef, h0_, (1/phi[lensID]));

for(i=0; i<3; i++)

{

ac_coef[i][lensID]=temp_ac_coef[i];

//aprt ac_coef[i][lensID];

};

//prt;

sc_ap(temp_sc_ap_coef, temp_sc_coef);

for(i=2; i>-1; i--)

{

sc_ap_coef[i][lensID]=temp_sc_ap_coef[i];

//aprintf("%f\t", sc_ap_coef[i][lensID]);

};

//prt;

cc_ap(temp_cc_ap_coef, temp_cc_coef, temp_sc_coef, q[lensID], u0_);

for(i=2; i>-1; i--)

{

cc_ap_coef[i][lensID]=temp_cc_ap_coef[i];

//aprintf("%f\t", cc_ap_coef[i][lensID]);

};

//prt;

ac_ap(temp_ac_ap_coef, temp_ac_coef, temp_cc_coef, temp_sc_coef, q[lensID], u0_);

for(i=2; i>-1; i--)

{

ac_ap_coef[i][lensID]=temp_ac_ap_coef[i];

//aprintf("%f\t", ac_ap_coef[i][lensID]);

};

//prt;

}

double surf_curv[6];

double AC_1_2;

double c5_coef[3];

double a,b,cc;

double c5[3];

double CC_1_3;

double c3;

double SC_total;

int srfID;

for (ii=1; ii<step; ii++)

{

surf_curv[0] = c1_start + ii*(c1_end - c1_start)/(step-1) ;

//prt surf_curv[0];

//change the C1, to get the C5;

//caculate AC*_1

AC_1_2 = ac_ap_coef[2][0] * surf_curv[0] * surf_curv[0] + ac_ap_coef[1][0] * surf_curv[0] + ac_ap_coef[0][0];

AC_1_2 += ac_ap_coef[0][1];

//prt "AC*_1_2=" AC_1_2;

c5_coef[2] = ac_ap_coef[2][2]; c5_coef[1] = ac_ap_coef[1][2];

c5_coef[0] = ac_ap_coef[0][2] + AC_1_2 - AC_target;

//prt "C5^2, C5^1, C5^0" (c5_coef[2]/c5_coef[2]) (c5_coef[1]/c5_coef[2]) (c5_coef[0]/c5_coef[2]);

a=c5_coef[2]; b=c5_coef[1]; cc=c5_coef[0];

//prt (b*b-4*a*cc);

if ( b*b-4*a*cc < 0 )

prt "No solution.";

else { c5[2] = (-1*b + sqrt(b*b-4*a*cc))/(2*a); c5[1] = (-1*b - sqrt(b*b-4*a*cc))/(2*a);}

//choose the less bending one, coef_calculating can be used

c5[0]=c5[1];

CC_1_3 = cc_ap_coef[2][0]*surf_curv[0]*surf_curv[0] + cc_ap_coef[1][0]*surf_curv[0] + cc_ap_coef[0][0];

CC_1_3 += cc_ap_coef[2][2]*c5[0]*c5[0] + cc_ap_coef[1][2]*c5[0] + cc_ap_coef[0][2];

//prt "CC_1_3=" CC_1_3;

c3 = (-1*cc_ap_coef[0][1]+(-1*CC_1_3)+CC_target)/cc_ap_coef[1][1];

//prt "C3=" c3;

sc_total = sc_ap_coef[2][0]*surf_curv[0]*surf_curv[0] + sc_ap_coef[1][0]*surf_curv[0] + sc_ap_coef[0][0];

sc_total += sc_ap_coef[2][1]*c3*c3 + sc_ap_coef[1][1]*c3 + sc_ap_coef[0][1];

sc_total += sc_ap_coef[2][2]*c5[0]*c5[0] + sc_ap_coef[1][2]*c5[0] + sc_ap_coef[0][2];

if (fabs(sc_total-SC_target)<0.001)

{

aprt "total SC = " sc_total;

aprt "C1, C3, C5" surf_curv[0] c3 c5[0];

break;

}

double th1;

double th2;

double th3;

input th1 "TH1";

input th2 "TH2";

input th3 "TH3";

len new "Cooke draft" total_efl;

ebr y1;

ang 1e-20;

des "ZhangJing";

uni 1.0;

sno1 "Produced by design_cooke.ccl";

wv wav1 wav2 wav3;

WW 1.0 1.0 1.0;

//srf 0

air;

ap 2e+19;

th 1.0e+20;

//srf 1

NXT;

gla mod "glass1" n[0] v[0];

cv surf_curv[0];

th th1;

ap noc y[0];

//srf 2

NXT;

air;

cv surf_curv[0]-c[0];

th airspace_1;

ap noc y[0];

//srf 3

NXT;

gla mod "glass3" n[1] v[1];

cv c3;

th th2;

ap noc y[1];

//srf 4

NXT;

air;

cv c3-c[1];

th airspace_2;

ap noc y[1];

ast;

//srf 5

NXT;

gla mod "glass5" n[2] v[2];

cv c5[0];

th th3;

ap noc y[2];

//srf 6

NXT;

air;

cv c5[0]-c[2];

th 0.0;

ap noc y[2];

//IMS

NXT;

air;

ap noc 0.0;

end;

stp outp on;

aprt (1/phi[0]);

aprt (1/phi[1]);

aprt (1/phi[2]);

scalecv(1,2, 1/phi[0]);

scalecv(3,4, 1/phi[1]);

scalecv(5,6, 1/phi[2]);

nodp(1,2,1);

e=ssb(sbrow-1,4);

nodp(3,4,1);

f=ssb(sbrow-1,3);

h=airspace_1+e-f;

th(2, h);

nodp(3,4,1);

e=ssb(sbrow-1,4);

nodp(5,6,1);

f=ssb(sbrow-1,3);

h=airspace_2+e-f;

th(4, h);

tra std loc All usr 1 0 n 1;

for (ii =1; ii<ims; ii++) ap(ii, chk, ssb(sbrow-8,1)+0.000001);

auf pxl;

ang fie_ang;

f 4 ins 1.2 0 0 0 0 -1.0 1.0 -1.0 1.0 1.0 0 0;

vig y y 5;

dlnr 1 0;

drw ims on;

stp outp on;

}

失落的命令

Sun, 25 Mar 2007 03:41:49 GMT

可以在帮助文档中找到关于text_toolbar_properties1的主题吗？

找出合适光阑位置的辅助工具

Tue, 06 Mar 2007 18:06:17 GMT

一些光学设计方面经验较少的初学者常会难于合理地设置光阑位置。例如下图，是测绘一个镜头后构建的系统。容易看出来，光阑被设置在不正确的位置上了。

图 1，错误的光阑位置

下面以OSLO内置的\public\len\demo\edu\demotrip.len文件为例，来说明如何使用ap_st函数来找到合适的光阑位置。

图 2，demotrip.len

打开这个三片镜后，在命令行输入AP_ST(20, -5, 30)，20即是镜头的视场角，-5和30是以镜头的第一个光学面顶点（图2中箭头所指处）为原点，在向左5mm，向右30mm的范围内搜索合适的光阑位置。文本窗口中输出结果如下。

$ The most possible position...

8.571429

$ The most possible position...

15.357143

$ The position below also can be tried...

11.785714

输出的数值即是以镜头的第一个光学面顶点（图2中箭头所指处）为原点的位置。该三片镜原有光阑位置为9mm（2mm + 6mm + 1mm），和第一个推荐的位置8.571429很接近。

现在用AP_ST(30, 0, 15)来寻找图一中合适的光阑位置。

$ The position below also can be tried...

8.469388

比对原始结构的数值后，发现胶合镜片的后一面是最接近这一数值的可能设置光阑的面，如下图。

图 3，正确的光阑位置

源码如下：

cmd ap_st(float half_angle, float left_end, float right_end)
{
int ii, anchor;
int step=99;
float step_length;

float original_ang, original_th0, original_th_ims;
float L_position[step], ray_height[step];
float derivative1st[step], derivative2nd[step];

//check whether obj dist is infinity
if(th[0]<1e20) abort("This is not an infinite conjugate system.");

original_ang=ang/dr;

stp outp off;
anchor=sbrow;

sbr anchor 1;
half_angle *= 0.7;
ang(half_angle);
original_th0=th[0];
original_th_ims=th[ims];
auf pxl;
//delete all the solve
for ( ii = 1; ii <= Imsnbr; ii++ )
{
 tsd(ii); // delete thickness solve on surface
 csd(ii); // delete curvature solve on surface
 if (apchk[ii]) ap(ii, noc, ap[ii]); // if aperture checking is on,

}

th(0,-1*left_end);

for ( ii = 0; ii < step; ii++)
{
 L_position[ii]=ii*(right_end-left_end)/(step-1);
 trb ful loc 0 0 L_position[ii] sin(half_angle*dr) 0 cos(half_angle*dr) 1 0 ims n;
 ray_height[ii]=ssb(sbrow-3,1);
 L_position[ii]+=left_end;
}

//calculate the 1st and 2nd derivative
step_length=(right_end-left_end)/(step-1);

for ( ii = 0; ii < step; ii++)
{
 if (ii==step-1)
 {
 derivative1st[ii]=derivative1st[ii-1];
 break;
 }
 derivative1st[ii]=(ray_height[ii+1]-ray_height[ii])/step_length;
}

prt; prt "*********************************"; prt;
for ( ii = 1; ii < step-1; ii++)
{
 if((ray_height[ii]-ray_height[ii-1])*(ray_height[ii]-ray_height[ii+1])>0)
 {
 prt "$ The most possible position...";
 prt L_position[ii];
 }
}

for ( ii = 0; ii < step-2; ii++)
{
 if (ii==step-1)
 {
 derivative2nd[ii]=derivative2nd[ii-1];
 break;
 }
 derivative2nd[ii]=(derivative1st[ii+1]-derivative1st[ii])/step_length;

}

for ( ii = 1; ii < step-1; ii++)
{
 if((derivative1st[ii]-derivative1st[ii-1])*(derivative1st[ii]-derivative1st[ii+1])>0)
 { prt "$ The position below also can be tried...";
 prt L_position[ii];
 }
}
prt; prt "*********************************";
th(0, original_th0);
th(ims, original_th_ims);
ang(original_ang);

sbr -1*anchor 0;
stp outp on;
return;
}

GENII zoom version

Tue, 26 Dec 2006 06:51:32 GMT

　　1993年，Sinclair Optics收购Genesee Optics Software后，OSLO获得了GENII中很多有特色的功能。简洁、高效的GENII评价函数就是其中之一。随着OSLO历次升级，GENII评价函仅在细节上略有演化——光线数减少等等。

　　然而，内置的GENII始终不支持zoom结构。或许OSLO原厂有其在光学设计实际意义上的考虑。但能将高效的GENII用于相对收敛较慢的zoom优化，总是一件好事。出于这个考虑我改写了可用于zoom结构的GENII评价函数生成程序。这个程序是对OSLO内置的geniierf修改而来，并且参考了Doffery的工作完成的，在此一并感谢。

#ifndef _OSLO_LIGHT_

#include "../../public/ccl/inc/gendefs.h"

cmd geniierf_zoom(double design_frequency_z, double f1_fymax_z, double f2_fymin_z,
 double f2_fymax_z, double f2_fx_z, double f3_fymin_z, double f3_fymax_z, double f3_fx_z,
 double f2_distol_z, double f3_distol_z, int max_cfg)
// hlp: OSLO Premium/OSLO Standard
// hlp: Generates a <a href="../optim/generation/genii.htm">Genii error function</a>.
// kwd: genii, error function, OCM, optimisation, error function builder
// cat: optimization
{
double uprime, dy, tmp;
int ssrow;
char tmpstr[32];
int opr_grp = 43; /* operands number for one configuration */

set_preference(output_text, off);
ssrow = sbrow();
ssbuf_reset(ssrow, 50);

/* basic transverse tolerance Dy */
dy = 1.0/(6.0*design_frequency_z);

/* delete old operands to enable new ray set */
operands(new);
end;

/* construct new ray set */
rayset(new);
/* field points <fby fbx fbz fyrf fxrf fymin fymax fxmin fxmax wgt> */
f(1, 0.0, 0.0, 0.0, 0.0, 0.0, -f1_fymax_z, f1_fymax_z, -f1_fymax_z, f1_fymax_z, 1.0);
f(2, 0.7, 0.0, 0.0, 0.0, 0.0, f2_fymin_z, f2_fymax_z, -f2_fx_z, f2_fx_z, 1.0);
f(3, 1.0, 0.0, 0.0, 0.0, 0.0, f3_fymin_z, f3_fymax_z, -f3_fx_z, f3_fx_z, 1.0);
/* rays <type fy fx> */
r(1, ref, 0.0, 0.0);
r(2, ord, 1.0, 0.0);
r(3, ord, -1.0, 0.0);
r(4, ord, 0.0, 1.0);
end();

/* new operand set */
operands(new);
end;
for ( i = 1; i < maxcfg + 1; i++)
{
/* switch to different configuration*/

cfg chg i;

  /* get current paraxial axial ray slope */
  paraxial_trace();
  uprime = -ssb(sbrow-1, 2);

  /* GENII "tolerances" */
  sprintf(tmpstr, "%.11e", dy);
  o(1 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_Dy tol");

  sprintf(tmpstr, "%.11e", 2.1*dy);
  o(2 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_2.1 Dy");

  sprintf(tmpstr, "%.11e", 2.8*dy);
  o(3 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_2.8 Dy");

  sprintf(tmpstr, "%.11e", 3.0*dy);
  o(4 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_3 Dy");

  sprintf(tmpstr, "%.11e", 4.0*dy);
  o(5 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_4 Dy");

  if (opdw)
   tmp = 1000.0*uni/wv[1];
  else
   tmp = 1.0;
  sprintf(tmpstr, "%.11e", tmp*uprime*dy/3.0);
  o(6 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_up Dy/3");
  sprintf(tmpstr, "%.11e", tmp*3.2*uprime*dy);
  o(7 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_3.2 up Dy");

/* on-axis targets */
/* pu(wvn, srf, cfg) axial ray slope (after refraction/reflection) */
 if (uprime < 0.0)
 sprintf(tmpstr, "%.11e+PU(1,%d,%d)", uprime, ims_1, i);
 else
 sprintf(tmpstr, "PU(1,%d,%d)+%.11e", ims_1, i, uprime);

 o(8 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_uprime"); /* paraxial axial ray slope in image space */

 sprintf(tmpstr, "O%d/0.0001", 8 + ( i - 1 ) * opr_grp); /* 0.0001 is experimental magic number */
 o(9 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0, "Fnb diff");

  /* dyy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DYY(1,1,1,%d)/O%d", i, 4 + ( i - 1) * opr_grp);
  o(10 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "Focus diff"); /* focus shift penalty */

    /* dy(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "DY(1,2,1,%d)/O%d", i, 1 + ( i - 1) * opr_grp);
  o(11 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "Axial DY");     /* transverse aberration */


  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(1,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(12 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "Axial OPD");   /* OPD on-axis */

  /* dmd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DMD(1,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(13 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "Axial DMD");   /* axial color (DMD) */

/* 0.7 field targets */
  sprintf(tmpstr, "%.11e", f2_distol_z);
  o(14 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_0.7 Dstol");

  /* dist(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "100*DIST(2,1,1,%d)", i );
  o(15 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_0.7 Dist");

  sprintf(tmpstr, "O%d/O%d", 15 + ( i - 1) * opr_grp, 14 + ( i - 1) * opr_grp);
  o(16 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 Dist");        /* Distortion */

  /* dyy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DYY(2,1,1,%d)/O%d", i, 2 + ( i - 1) * opr_grp);
  o(17 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 YFS");     /* tangential field curvature */

  /* dxx(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DXX(2,1,1,%d)/O%d", i, 2 + ( i - 1) * opr_grp);
  o(18 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 XFS");     /* sagittal field curvature */

  /* s2t(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "S2T(2,1,1,%d)/O%d", i, 7 + ( i - 1) * opr_grp);
  o(19 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 Coma");    /* primary aperture coma */

    /* dy(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "DY(2,2,1,%d)/O%d", i, 3 + ( i - 1) * opr_grp);
  o(20 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 DY U");     /* transverse aberration in upper aperture */

  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(2,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(21 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 OPD U");   /* OPD in upper aperture */

    /* dmd(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "DMD(2,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(22 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 DMD U");   /* DMD for lateral color in upper aperture */

  /* dy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DY(2,3,1,%d)/O%d", i, 3 + ( i - 1) * opr_grp);
  o(23 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 DY L");     /* transverse aberration in lower aperture */

  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(2,3,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(24 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 OPD L");   /* OPD in lower aperture */

  /* dmd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DMD(2,3,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(25 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 DMD L");   /* DMD for lateral color in lower aperture */

  /* dx(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DX(2,4,1,%d)/O%d", i, 3 + ( i - 1) * opr_grp);
  o(26 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 Sag DX");   /* transverse aberration x-component for sagittal ray */

  /* dy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DY(2,4,1,%d)/O%d", i, 1 + ( i - 1) * opr_grp);
  o(27 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "0.7 Sag DY");   /* transverse aberration y-component for sagittal ray */

  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(2,4,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(28 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, ".7 Sag OPD"); /* OPD for sagittal ray */

/* 1.0 field targets */
  sprintf(tmpstr, "%.11e", f3_distol_z);
  o(29 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_1.0 Dstol");

  /* dist(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "100*DIST(3,1,1,%d)", i);
  o(30 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 0.0, "_1.0 Dist");

  sprintf(tmpstr, "O%d/O%d", 30 + ( i - 1) * opr_grp, 29 + ( i - 1) * opr_grp);
  o(31 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 Dist");        /* Distortion */

  /* dyy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DYY(3,1,1,%d)/O%d", i, 4 + ( i - 1) * opr_grp);
  o(32 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 YFS");     /* tangential field curvature */

  /* dxx(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DXX(3,1,1,%d)/O%d", i, 1 + ( i - 1) * opr_grp);
  o(33 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 XFS");     /* sagittal field curvature */

  /* s2t(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "S2T(3,1,1,%d)/O%d", i, 7 + ( i - 1) * opr_grp);
  o(34 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 Coma");    /* primary aperture coma */

  /* dy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DY(3,2,1,%d)/O%d", i, 5 + ( i - 1) * opr_grp);
  o(35 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 DY U");     /* transverse aberration in upper aperture */

  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(3,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(36 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 OPD U");   /* OPD in upper aperture */

    /* dmd(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "DMD(3,2,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(37 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 DMD U");   /* DMD for lateral color in upper aperture */

    /* dy(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "DY(3,3,1,%d)/O%d", i, 5 + ( i - 1) * opr_grp);
  o(38 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 DY L");     /* transverse aberration in lower aperture */

  /* opd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "OPD(3,3,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(39 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 OPD L");   /* OPD in lower aperture */

  /* dmd(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DMD(3,3,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(40 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 DMD L");   /* DMD for lateral color in lower aperture */

  /* dx(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DX(3,4,1,%d)/O%d", i, 5 + ( i - 1) * opr_grp);
  o(41 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 Sag DX");   /* transverse aberration x-component for sagittal ray */

  /* dy(fpt, ray, wvn, cfg) */
  sprintf(tmpstr, "DY(3,4,1,%d)/O%d", i, 1 + ( i - 1) * opr_grp);
  o(42 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1.0 Sag DY");   /* transverse aberration y-component for sagittal ray */

    /* opd(fpt, ray, wvn, cfg) */
    sprintf(tmpstr, "OPD(3,4,1,%d)/O%d", i, 6 + ( i - 1) * opr_grp);
  o(43 + ( i - 1 ) * opr_grp, ins, tmpstr, min, 1.0, "1 Sag OPD");   /* OPD for sagittal ray */

}
/* end of new operand set*/

ssbuf_reset(-ssrow, 0);
set_preference(output_text, on);
}

#endif

2006年度Glassmap最佳伴侣

Sat, 19 Aug 2006 17:59:16 GMT

　　新的命令GN可以实现以下功能，一，定位玻璃所在行数；二，根据当前波长选择计算折射率和色散；三，查询玻璃图中相邻玻璃的参数，而不引起玻璃图刷新。

　　例如，在Schott目录中查询K11玻璃，可以在Schott玻璃数据库打开的状态下输入gn k11。在文本窗口中可以看到K11玻璃在第10行，同时也输出按照当前波长计算的n和v。另外，键入gn bk7，就可以在玻璃图没有任何刷新，焦点没有变化的情况下输出BK7的参数。

double dispersion(double lambda, int disp_model, double c0, double c1, double c2, double c3, double c4, double c5)
{
 double refractive_index;
 switch(disp_model)
 {
 case 1: //if (Dispersion model == Laurent)
 if((refractive_index = (c0+(c1*pow(lambda,2))+(c2*pow(lambda,-2))+(c3*pow(lambda,-4))+(c4*pow(lambda,-6))+(c5*pow(lambda,-8))))<0)
 refractive_index = 1.0;
 refractive_index = sqrt(refractive_index);
 break;

 case 2: //if (Dispersion model == Sellmeier)
 lambda *= lambda;
 refractive_index = sqrt(1+(c0*lambda/(lambda-c3))+(c1*lambda/(lambda-c4))+(c2*lambda/(lambda-c5)));
 break;

 case 3: //if (Dispersion model == Conrady)
 refractive_index = c0+(c1/lambda)+(c2*pow(lambda,-3.5));
 break;

 default:
 prt("error in dispersion mode %d", mode);
 refractive_index = 1.0;
 break;
 }
 return refractive_index;
}

cmd gn(char gn[])
{
 char glassname[2000][18], tmpstr[18];
 int rows_number, found = 0, model;
 double cf0, cf1, cf2, cf3, cf4, cf5;
 double wv_short = wv[2], wv_middle = wv[1], wv_long = wv[3];
 double n, delta_n, v;

 dbgsc(glassname,0,1);
 ary2strcpy(tmpstr, glassname, 0);
 rows_number = atol(tmpstr);
 for (i = 1; i < (rows_number + 1); i++ )
 {
 ary2strcpy(tmpstr, glassname, i);
 if (!stricmp(gn, tmpstr))
 {
 found = 1;
 dbgie(&model, i, 13);
 dbgre(&cf0, i, 15);
 dbgre(&cf1, i, 16);
 dbgre(&cf2, i, 17);
 dbgre(&cf3, i, 18);
 dbgre(&cf4, i, 19);
 dbgre(&cf5, i, 20);
 n = dispersion(wv_middle, model, cf0, cf1, cf2, cf3, cf4, cf5);
 delta_n = dispersion(wv_short, model, cf0, cf1, cf2, cf3, cf4, cf5) - dispersion(wv_long, model, cf0, cf1, cf2, cf3, cf4, cf5);
 v = (n-1)/delta_n;
 prt "*Row Glass N V";
 aprt i " " tmpstr n v;
 break;
 }
 }
 if (!found) message("Error in glass name!");
}

弯曲镜片并保持焦距的函数

Sat, 05 Aug 2006 17:36:13 GMT

　　有时我们需要对镜片进行弯曲，而保持其单个镜片的焦距不变。如果我们仅将镜片两侧的曲率同时修改某个数值，是达不到这样的效果的。以下用OSLO安装路径中\public\len\demo\light\tutorial\dblgauss1.len为例说明。

　　如果仅仅同时增加第一片镜片两侧的曲率，例如0.005：

　　使用以下提供的bend命令增加第一面的曲率，例如0.005：

　　同时，bend函数中也演示了如何在CCL程序中切换优化变量和优化算子。因此，尽管bend函数调用的OSLO内置的ite，但仍保留了原有的变量和优化算子。

//Revised 2006-08-07; correct for negative component

#include "../../public/ccl/inc/vbdata.h"
#include "../../public/ccl/inc/strdefs.h"

cmd getvar(double current_variables[][])
{
 int error;
 if (error = getvdat(current_variables))
 {
  if (error == -1)    prt "No variables";
  else if (error == -2 ) prt "File opening error";
 }
}

cmd cleanup_var()
{ 
 for (i = varnbr-1; i > 0; i--) v(i, del);
}

cmd retrieve_var(double variable_list[][], int original_num)
{
 int tmp_srf_num;
 int tmp_cfg_num;
 int tmp_var_typ;
 
 for (i = 1; i < original_num; i++)
 {
  tmp_srf_num = r2int(variable_list[i][0]);
  tmp_cfg_num = r2int(variable_list[i][1]);
  tmp_var_typ = r2int(variable_list[i][2]);
  switch (tmp_var_typ)
  {
   case 1: v(i, ins, tmp_srf_num, tmp_cfg_num, CV, variable_list[i][3], variable_list[i][4], variable_list[i][5], variable_list[i][6]);
       break;
   case 2: v(i, ins, tmp_srf_num, tmp_cfg_num, CC, variable_list[i][3], variable_list[i][4], variable_list[i][5], variable_list[i][6]);
       break;   
   case 3: v(i, ins, tmp_srf_num, tmp_cfg_num, TH, variable_list[i][3], variable_list[i][4], variable_list[i][5], variable_list[i][6]);
       break;
   default: message("Variable type error!"); break;
  }  
 }
}

cmd getope(int op_num[], int op_mod[], double op_wgt[], double op_tgt[], char op_nam[][], char op_def[][])
{
 int error;
 char tmpstr[50];
 for (i = 1; i < oprnbr; i++)
 {
  op_num[i] = i;
  op_mod[i]=opmode[i-1];
  if (op_mod[i]) op_tgt[i]=optgt[i-1];
   else op_wgt[i]=opwgt[i-1];
  get_operand_name(i-1);
  if (error = str2arycpy(op_nam, operand_name, i)) message(error);
  get_operand_def(i-1);
  if (error = str2arycpy(op_def, operand_definition, i)) message(error);
 } 
}

cmd cleanup_ope()
{
 for (i = oprmax; i > 0; i--) o(i, del);
}

cmd retrieve_ope(int total, int number[], int mode[], double weight[], double target[], char name[][], char definition[][])
{
 char tmp_nam[11];
 char tmp_def[50];
 for (i = 1; i < total; i++)
 {
  ary2strcpy(tmp_nam, name, i);
  ary2strcpy(tmp_def, definition, i);
  switch (mode[i])
  {
   case 0: o(i, ins, tmp_def, min, weight[i], tmp_nam); break;
   case 1: o(i, ins, tmp_def, con, target[i], tmp_nam); break;
   default: message("Operand mode error!"); break;
  }
 }
}


cmd auto()
{
 int original_varnbr = varnbr;
 int original_oprnbr = oprnbr;
 double saved[original_varnbr][8];
 
 double original_efl;
 double original_opst=opst;
 double new_opst=0.000001;
 char set_operand[50];
 
 int O_op_num[original_oprnbr];
 int O_op_mod[original_oprnbr];
 double O_op_wgt[original_oprnbr];
 double O_op_tgt[original_oprnbr];
 char O_op_nam[original_oprnbr][11];
 char O_op_def[original_oprnbr][50];
 
 int tmp_srfnum, compensation;
 double delta_cv;
 int first, second;
 
 getvar(saved);
 getope(O_op_num, O_op_mod, O_op_wgt, O_op_tgt, O_op_nam, O_op_def);
 cleanup_var();
 cleanup_ope();

 input(&tmp_srfnum, "Which surface you change?");
 input(&delta_cv, "How much curvature you change?");
 input(&compensation, "Which surface compensate?");
 
 input(&first, "Which is the first surface?");
 input(&second, "Which is the second surface?");
 if ((original_efl=pe_efl(first, second)) >= 0)
  sprintf(set_operand, "EFL(%d,%d,1)-%.6f", first, second, original_efl);
  else sprintf(set_operand, "EFL(%d,%d,1)+%.6f", first, second, fabs(original_efl));
 
 
 
 
 cv(tmp_srfnum,cv[tmp_srfnum]+delta_cv);
 v(1, ins, compensation, 0, CV, 0, 0, 1, 0);
 prt set_operand;
 prt OK1;
 o(1, ins, set_operand, min, 100.0, "EFL");
 prt OK2;
 opst(new_opst);
 prt opst, new_opst;
 ite ful 100;
 opst(original_opst);
 cleanup_var();
 cleanup_ope(); 
 retrieve_var(saved, original_varnbr);
 retrieve_ope(original_oprnbr, O_op_num, O_op_mod, O_op_wgt, O_op_tgt, O_op_nam, O_op_def);
}

烛光花影两相宜

Mon, 31 Jul 2006 16:52:09 GMT

　　OSLO 6.2.x没有提供vari_sfn等等的读取接口，范例程序中展示了读取该变量底层的实作技巧。OSLO 6.3.x的CCL global data就提供了这一项，非常简洁。

　　这从另一角度说明了OSLO中“The lens is the document”的概念。

依照两主面间距离计算面间距

Sun, 30 Jul 2006 17:50:14 GMT

　　这是依照两主面间距离计算面间距的一个小的SCP程序，由近轴计算换成厚透镜时用得上。

*PP
//set thickness according the principal plane distance
stp outp off;
input(&i, "Input the first surface of the first group:");
input(&j, "Input the last surface of the first group:");
input(&k, "Input the first surface of the second group:");
input(&l, "Input the last surface of the second group:");
nodp(i,j,1);
e=ssb(sbrow-1,4);
nodp(k,l,1);
f=ssb(sbrow-1,3);
input(&g, "Input the distance between two PP:");
h=g+e-f;
stp outp on;
aprt "The distance between" j "and" k "should be" h;

当然，也可以说程序风格很好

Wed, 19 Apr 2006 08:02:54 GMT

　　OSLO 的 xsource 源文件中有一小段重复代码，是为了良好的风格吗？

改进版本的xsource命令

Mon, 17 Apr 2006 02:18:02 GMT

　　图一是OSLO中Source->Pixelated Object菜单（Xsource）的图形输出结果。当光线取样数增大到一定程度，xsource的输出已经无法让设计者清楚的了解成像情况。

图一

　　修改后的输出如图二。

图二

用于手工修改结构的双参数图函数

Thu, 13 Apr 2006 02:04:54 GMT

用于手工修改结构的双参数图函数

　　常见的光学软件如OSLO，Zemax都提供了slider，便于直观的手工修改镜头结构。以OSLO为例，它内置ray-intercept、OPD、field sag、spot diagram和long. SA的即时callback图形输出，但这并不能满足所有的手工修改需求。双参数图就是一个很有用的补充。它本质是解二元一次方程和线性逼近，在使用上也和slider略有不同——使用slider是设计者尝试调节一些参数，然后观察变化，继续尝试下一步的修改；而双参数图则是调节敏感参数，计算目标像差变化，进而得到下一步的修改量。

　　目前提供的函数版本还有少许缺憾——没有输出参数变化量的符号。符号必须根据图形来判断，同向为正，反向取负。

图1：图形及文字输出

//Function to draw double graph.
//Zhang Jing
//2006-03-15

cmd dg_dist(float p1[], float p2[], float distance)
{
    distance=sqrt((p1[0]-p2[0])*(p1[0]-p2[0])+(p1[1]-p2[1])*(p1[1]-p2[1]));
    return;
}

cmd dg()
{
    float point_0[2], point_1[2], point_2[2];
    float point_aim[2];
    float dist_0, dist_1;
    float x_temp, y_temp;
    float line_coef[3][3], equa_coef[2][2];
    float k2;
    float intersec[2];
    float constant[2];
    float dist_temp, dist[2], req_change[2];

    input(&x_temp, "Input the x-coordinate of the aim point:");
    point_aim[0] = x_temp;
    input(&y_temp, "Input the y-coordinate of the aim point:");
    point_aim[1] = y_temp;

    input(&x_temp, "Input the x-coordinate of the 1st point:");
    point_0[0] = x_temp;
    input(&y_temp, "Input the y-coordinate of the 1st point:");
    point_0[1] = y_temp;

    input(&dist_0, "Input the change of the 1st parameter:");

    input(&x_temp, "Input the x-coordinate of the 2nd point:");
    point_1[0] = x_temp;
    input(&y_temp, "Input the y-coordinate of the 2nd point:");
    point_1[1] = y_temp;

    input(&dist_1, "Input the change of the 2nd parameter:");

input(&x_temp, "Input the x-coordinate of the 3rd point:");
 point_2[0] = x_temp;
 input(&y_temp, "Input the y-coordinate of the 3rd point:");
 point_2[1] = y_temp;

 line_coef[0][0]=point_1[0]-point_0[0];
 line_coef[0][1]=point_0[1]-point_1[1];
 line_coef[0][2]=point_1[0]*point_0[1]-point_0[0]*point_1[1];

 line_coef[1][0]=point_2[0]-point_1[0];
 line_coef[1][1]=point_1[1]-point_2[1];
 line_coef[1][2]=point_2[0]*point_1[1]-point_1[0]*point_2[1];

 k2=(point_2[1]-point_1[1])/(point_2[0]-point_1[0]);

 line_coef[2][0]=1;
 line_coef[2][1]=-1*k2;
 line_coef[2][2]=point_aim[1]-k2*point_aim[0];

 equa_coef[0][1]=line_coef[0][0]; equa_coef[0][0]=line_coef[0][1]; constant[0]=line_coef[0][2];
 equa_coef[1][1]=line_coef[2][0]; equa_coef[1][0]=line_coef[2][1]; constant[1]=line_coef[2][2];

 slveqs(equa_coef, intersec, constant);

 dg_dist(intersec, point_0, &dist_temp);
 dist[0]=dist_temp;
 dg_dist(point_1, point_0, &dist_temp);
 req_change[0]=dist[0]/dist_temp*dist_0;

 aprt "The 1st parameter should change", req_change[0];

 dg_dist(intersec, point_aim, &dist_temp);
 dist[1]=dist_temp;
 dg_dist(point_2, point_1, &dist_temp);
 req_change[1]=dist[1]/dist_temp*dist_1;

 aprt "The 2nd parameter should change", req_change[1];

 float max_dim, factor;
 max_dim=fabs(point_aim[0]);
 if(max_dim<fabs(point_aim[1])) max_dim=fabs(point_aim[1]);
 if(max_dim<fabs(point_0[0])) max_dim=fabs(point_0[0]);
 if(max_dim<fabs(point_0[1])) max_dim=fabs(point_0[1]);
 if(max_dim<fabs(point_1[0])) max_dim=fabs(point_1[0]);
 if(max_dim<fabs(point_1[1])) max_dim=fabs(point_1[1]);
 if(max_dim<fabs(point_2[0])) max_dim=fabs(point_2[0]);
 if(max_dim<fabs(point_2[1])) max_dim=fabs(point_2[1]);

 factor=100/max_dim*0.75;
 point_aim[0]*=factor;
 point_aim[1]*=factor;
 point_0[0]*=factor;
 point_0[1]*=factor;
 point_1[0]*=factor;
 point_1[1]*=factor;
 point_2[0]*=factor;
 point_2[1]*=factor;
 intersec[0]*=factor;
 intersec[1]*=factor;

 float iplt;
 graphwin_reset;
 moveto(0.5, 0.92);
 lorigin(4);
 label("Double graph for %s",Lid);

 window(-120, 120, -110, 130);
 moveto(-100, 0);
 lineto(100, 0);
 for (iplt = -10; iplt <11; iplt++)
 {
 moveto(iplt*10, 0);
 linerel(0, -3);
 lsize 0.3;
 lorigin 56;
 label("%-4.3f",iplt*2*max_dim/10);

}
 moverel(-20,-10);
 label("x-axis");
 moveto(0, -100);
 lineto(0, 100);
 for (iplt = -10; iplt <11; iplt++)
 {
 moveto(0, iplt*10);
 linerel(2, 0);
 lsize 0.3;
 label("%-4.2f",iplt*2*max_dim/10);
 }

 moverel(5,-10);
 label("y-axis");

 moveto(point_aim[0], point_aim[1]);
 symbol 7;
 lsize 0.3;
 label("Aim");

 moveto(point_0[0], point_0[1]);
 symbol 3;
 lsize 0.3;
 label("Start");

 moveto(point_0[0], point_0[1]);
 lineto(point_1[0], point_1[1]);

 symbol 5;
 lineto(point_2[0], point_2[1]);
 symbol 6;

pen(2);

    moveto(intersec[0],intersec[1]);
    symbol 8;
    lineto(point_aim[0], point_aim[1]);
    moveto(intersec[0],intersec[1]);
    lineto(point_0[0], point_0[1]);
    return;
}

按焦距比例缩放曲率

Mon, 10 Apr 2006 01:24:26 GMT

　　OSLO内置的scale功能会将曲率和厚度一同缩放，而我常常只需要将曲率微调而保持厚度不变，所以写了这个函数自己用。

cmd scalecv(float efl)
{ //仅对曲率作缩放，达到合适的EFL
 float tol=0.00000001
 float feedback=1.0;
 stp outp off;
 int counter;
 do{
 for(counter=1;counter<ims;counter++)
 cv(counter,cv[counter]*feedback);
 feedback=pe_efl(1,ims_1)/efl;
 }
 while(fabs(feedback-1)>tol);
 stp outp on;
}

对称式镜头后部初始结构计算函数

Wed, 29 Mar 2006 02:07:55 GMT

对称式镜头后部初始结构计算函数

　　在传统的镜头设计手法中，对于对称式的镜头，常由后半部开始设计。典型的例子有Celor和Double Gauss，如下图。

　　以下函数根据预先选定的玻璃，光焦度，Petzval sum和纵向色差计算出镜片的曲率和间距。其中，双高斯镜头的Petzval sum可以选的略小一些。在"Introduction to lens design"的318页也提到了这个计算公式，我粗略的看了一下，应该是一致的，但没有做详细的对照检查。

cmd rear(float n_a, float v_a, float n_b, float v_b, float phi, float ptz, float lch)
{
 float a, b, c;
 float delta;
 float phi_a_1, phi_b_1;
 float phi_a_2, phi_b_2;
 float d1, d2;
 float c_a, c_b;

 a = v_a - n_b * v_b / n_a ;
 b = ptz * n_b * v_b - 2 * phi * v_a - ( lch * phi * phi * n_b * v_b ) / n_a ;
 c = phi * phi * v_a * ( 1 + lch * ptz * n_b * v_b );

 delta = b * b - 4 * a *c;

 if(delta<0)
 {
 prt "Your requirement can not be satisfied by these glasses!";
 return;
 }

 phi_a_1=(-1*b+sqrt(delta))/(2*a);
 phi_a_2=(-1*b-sqrt(delta))/(2*a);
 prt phi_a_1, phi_a_2;

 phi_b_1=n_b*(ptz-phi_a_1/n_a);
 phi_b_2=n_b*(ptz-phi_a_2/n_a);
 prt phi_b_1, phi_b_2;

 d1=(phi_a_1+phi_b_1-phi)/(phi_a_1*phi_b_1);
 d2=(phi_a_2+phi_b_2-phi)/(phi_a_2*phi_b_2);
 prt d1, d2;

 c_a=phi_a_1/(n_a-1);
 c_b=phi_b_1/(n_b-1);

 aprt "c_a= ",c_a," ", "c_b= ",c_b;
 return;
}

对0.7带消色差的SCP程序

Wed, 30 Nov 2005 07:18:44 GMT

以下是对0.7带消色差的SCP程序，提供两个选择：修改末面半径或者替换玻璃。

如果需要对其它带消色差，可以反馈你的具体需求。

ps. 我一直很想改写成结构更合理的CCL版本，只是这个SCP版的用了相当一段时间，还比较好用，所以没有太多的动力改写了。

*achromatize
stp outp off;
input(&ii,"1,Change last radius; 2,check available abbe nbr");
trr "f" 1 1;
switch(ii)
{
case 1:
 for(i=ims_1;i>0;i--)
 {
 get_glass_name(i);
 if(strcmp(glass_name, "AIR ")!=0)
 {
 tra std loc Srf usr 1 0 0 i+1 y 1;
 for(j=0;j<i+2;j++)
 {
 Ua[j]=ssb(sbrow-i+j-3,6);
 }
 for(j=0,d=0;j<i;j++)
 {
 get_glass_name(j);
 if(strcmp(glass_name, "AIR ")!=0)
 {
 Va[j]=(Ua[j+1]-th[j])*(rn[j][2]-rn[j][3]);
 }
 else Va[j]=0;
 d+=Va[j];
 }
 printf("DMD before the last glass is %f\n",d);
 e=-1*d/(rn[i][2]-rn[i][3])+th[i];
 print "wanted D=" e;
 tra std loc Srf usr 1 0 0 i y 1;
 f=ssb(sbrow-2,1);
 g=ssb(sbrow-2,3);
 h=-1*ssb(sbrow-2,4)*dr;
 o=e*cos(h)+g-th[i];
 p=f-e*sin(h);
 q=(o*o+p*p)/(2*o);
 i=0;
 }
 }
 stp outp on;
 aprint "last Radius should be" q;
 break;
case 2:
 tra std loc Srf usr 1 0 0 ims_1 y 1;
 for(i=0;i<ims;i++)
 {
 Ua[i]=ssb(sbrow-ims-1+i,6);
 m=i;
 }
 for(i=0;i<m+1;i++)
 {
 get_glass_name(i);
 if(strcmp(glass_name, "AIR ")!=0)
 {
 Xa[i]=Ua[i+1]-th[i];
 Ya[i]=rn[i][2]-rn[i][3];
 Va[i]=Xa[i]*Ya[i];
 }
 else Va[i]=0;
 }
 stp outp on;
 for(i=0;i<m+1;i++)
 {
 if(fabs(Va[i])>0.00001)
 {
 for(j=0,s=0;j<m+1;j++)
 {
 if(j!=i)
 {
 s+=Va[j];
 }
 }
 Wa[i]=-1*s/Xa[i];
 Za[i]=(rn[i][1]-1)/Wa[i];
 aprintf("Suggested Abbe nbr of srf %d is %f\n",i,Za[i]);
 }
 else Wa[i]=0,Za[i]=0;
 }
 break;
default:
 stp outp on;
 print "Please choose 1 or 2!";
 break;
}

球差贡献计算程序

Thu, 17 Nov 2005 06:26:55 GMT

这个球差贡献计算程序两个月前就写了，但是spreadsheet buffer的操作上有点小bug，现在修改好了。

请注意，这不是球差贡献的三阶、五阶或者七阶系数计算公式，而是实际球差贡献的计算公式。也可以用sac()来计算OCM算子，对实际球差贡献进行优化。

#include "../../public/ccl/inc/gendefs.h"

float sac(int srfnum, float zone, int sac_type)
// hlp: srfnum is the number of the surface, 0 stands for the sum of all the surfaces
// hlp: zone is the pupuil zone, 1 stands for margin, 0 stands for the axial
// hlp: sac_type==0 means longitudinal spherical aberration;
// hlp: sac_type==1 means transverse spherical aberration
// hlp: Please use " prt sac(2, 0.7, 0) " to show the 2nd surface's SA contribution @ 0.7 zone
// hlp: Please use " prt sac(0, 1, 1) " to show the SA contribution summation @ marginal zone.
// kwd: spherical aberration, evaluation
// cat: evaluation tools
{
int counter, anchor, lines, sbfrow;
float ytemp, ztemp;
float PA[ims];
float Iang[ims],Rang[ims],Uang[ims],index[ims];
float i_para[ims],ulast;
float sa_total[ims];
float sum=0;

SAVE_DISPLAY_PREFS;
sbfrow = sbrow();
sbr(sbfrow, 1);
stp outp off;

trr f 1 1;
tra ful loc srf usr zone 0 0 ims_1 y 1;
anchor=sbrow-2*ims-1;
for(counter=0;counter<ims;counter++)
{
 ytemp=ssb(anchor+2+counter*2,1);
 ztemp=ssb(anchor+2+counter*2,3);
 PA[counter]=sqrt(ytemp*ytemp+ztemp*ztemp);
 Iang[counter]=ssb(anchor+3+counter*2,4);
 Rang[counter]=ssb(anchor+3+counter*2,5);
 Uang[counter]=ssb(anchor+counter*2,4);
 }

rin srf 0 ims_1;
lines=0.9+numw/3;
anchor=sbrow-ims*lines;
for(counter=0;counter<ims;counter++)
{
 index[counter]=ssb(anchor+counter*lines,1);
 }

pxt srf 0 ims_1 y 1;
anchor=sbrow-ims_1;
for(counter=0;counter<ims;counter++)
{
 i_para[counter]=ssb(anchor+counter,3);
 if(i_para[counter]<0)
 {
 Iang[counter]=-1*fabs(Iang[counter]);
 Rang[counter]=-1*fabs(Rang[counter]);
 }
 else
 {
 Iang[counter]=fabs(Iang[counter]);
 Rang[counter]=fabs(Rang[counter]);
 }
 }
pxt; ulast=ssb(sbrow-1,2);

for(counter=0;counter<ims;counter++)
{
 sa_total[counter]=2*index[counter]*i_para[counter]*PA[counter]*sin(0.5*(Rang[counter]-Iang[counter])*dr)*sin(0.5*(Rang[counter]+Uang[counter])*dr)/(index[ims_1]*ulast*sin(Uang[ims_1]*dr));
 sum+=sa_total[counter];
 }

ssbuf_reset(-sbfrow, 0);
RESTORE_DISPLAY_PREFS;
stp outp on;
switch(sac_type)
{
  case 0:
   if(srfnum==0)
   return sum;
   else return sa_total[srfnum-1];
  case 1:
   if(srfnum==0)
   return sum*tan((-1)*Uang[ims_1]*dr);
   else return sa_total[srfnum-1]*tan((-1)*Uang[ims_1]*dr);
  }
}

Least square optimization without damping

Wed, 02 Nov 2005 09:34:08 GMT

Flow chart revised 2

Tue, 25 Oct 2005 03:23:43 GMT

Flow chart revised

Mon, 24 Oct 2005 09:53:50 GMT

天外飞仙

Mon, 24 Oct 2005 02:49:55 GMT

optim_ge.ccl 文件的第219行，平白无故的多出一句：

m = 0;

真是来无影，去无踪。

gexplore()中并没有声明m这样一个局部变量，而且m在程序中也没有起到什么作用。

好在m是OSLO的Predefined General Variables，编译时才没有什么问题/或者说漏出了这个小的defect。

Flow chart of Global explorer

Mon, 24 Oct 2005 01:18:52 GMT

分享我绘制的Global explorer的流程图。我的原图是4033×2849分辨率的，可是http://www.flickr.com/最大只支持到1024×768。有没有更好的办法？

流程图用Powerpoint绘制的，没有Visio，画得拥挤。不知道有没有什么小的工具软件，用来画流程图很好的？

Global Explorer for OSLO

Wed, 19 Oct 2005 09:49:01 GMT

读完的595行的源程序，了解了一些实作的细节。

程序风格不是很好，gexplore()和find_duplicates()中就有相当的重复代码。

Global explorer中的代码有相当分量是用来处理lensol[][]这个队列的（这一部分的代码风格很不好），另外用来绘制适合用户理解的图形也花费了大量的代码。其中，真正用来完成逃逸优化的代码行数相当少。另外强行设定了可处理的最大优化变量数为100，这个也不是很合理。

有没有改写一下的可能呢?

或者用STL来完成对lensol[][]队列的操作？

增强的Glassmap功能

Mon, 05 Sep 2005 03:30:34 GMT

我对OSLO内置的Glassmap功能做了一个增强：点击左边玻璃名，除了原有的highlight在nd-vd图（右上）中，也会同时highlight在pv-nd图（右下）中。
目前仍有两个问题：
1. 如何快速方便的选择目标波长，用来验算部分色散？使用wse中的现有波长（第四或者更后的）？应该尽量避免修改CCL程序，重新编译这一过程。
2. Misc目录中无法用通常方法计算色散的材料如何处理？应充分提醒用户注意材料色散的实际物理意义。