This shows you the differences between two versions of the page.
Both sides previous revision Previous revision Next revision | Previous revision | ||
vatt:legacy_psuedo-hexpod [2017/07/11 14:22] scott |
— (current) | ||
---|---|---|---|
Line 1: | Line 1: | ||
- | ====== VATT Psuedo Hexapod Legacy ====== | ||
- | The VATT secondary is focused and collimated with a Psuedo Hexapod. Motion between the axes are coupled but as little as possible and we get uncoupled positions with some linear algebra and iterations. The psuedo hexapod is to be retired for a PI hexapod which will hopefully be installed summer 2017 | ||
- | |||
- | ===== Software ===== | ||
- | |||
- | The VATT secondary is controlled using a c program that runs on vatttel. You can find the source in our mogit repository. The most source file is secmove.c. | ||
- | |||
- | |||
- | {{: | ||
- | |||
- | |||
- | <code c> | ||
- | /* VATT secondary move routine | ||
- | * The six user motions are all cross coupled | ||
- | * into the six motors on the VATT secondary. | ||
- | * Hence, all the matrix math. | ||
- | * This will be a replacement for winsec.c | ||
- | */ | ||
- | #define abs(a) | ||
- | |||
- | extern void sprintf(); | ||
- | extern void printf(); | ||
- | extern int sec_checkVoltsOK(); | ||
- | extern void movev(); | ||
- | extern void vme8_kill(); | ||
- | |||
- | double sec_dv = 0.03; /* maximum allowable voltage difference */ | ||
- | double sec_dvmax = 0.2; /* maximum before kill */ | ||
- | double sec_min_temp = -40.0; /* minimum sane temperature */ | ||
- | double sec_max_temp = 50.0; /* maximum sane temperature */ | ||
- | double sec_min_cosel = 0.0; /* minimum sane cosine(elevation) */ | ||
- | double sec_max_cosel = 1.0; /* maximum sane cosine(elevation) */ | ||
- | double sec_lastgood_temp; | ||
- | double sec_lastgood_cosel; | ||
- | int sec_max_mloops = 5; /* maximum motor loops */ | ||
- | |||
- | #define V | ||
- | #define M | ||
- | #define TIPX 0 /* arcseconds */ | ||
- | #define TIPY 1 | ||
- | #define TIPZ 2 | ||
- | #define DECENX | ||
- | #define DECENY | ||
- | #define FOCUS 5 | ||
- | |||
- | double sec_threshold[M] = {2.5, 2.5, 2.5, 4.5, 4.5, 1.0}; | ||
- | char sec_errormessage[100]; | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | |||
- | /* The immediately above positions are derived from the lvdt readings | ||
- | * and multiplied by v2m, then the zero offset is removed. | ||
- | */ | ||
- | |||
- | #define C | ||
- | #define FTC 0 | ||
- | #define FLC 1 | ||
- | #define CTC 2 | ||
- | #define CLC 3 | ||
- | |||
- | |||
- | /* the original Steve West matrix | ||
- | */ | ||
- | double sec_m2v_sw[V][M] = { | ||
- | {0.0029680, | ||
- | {0.0016000, | ||
- | {0.0029300, | ||
- | {-0.001475, | ||
- | {-0.005346, | ||
- | {-0.0001785, | ||
- | }; | ||
- | |||
- | /* All new values per cromwell 10/6/97 | ||
- | * Most of these are now updated in startup.cmd | ||
- | */ | ||
- | |||
- | double | ||
- | double | ||
- | |||
- | double sec_m2v[V][M] = { | ||
- | {0.0029680, | ||
- | {0.0016000, | ||
- | {0.0029300, | ||
- | {-0.001475, | ||
- | {-0.005346, | ||
- | {-0.0001785, | ||
- | }; | ||
- | |||
- | double sec_v2m[M][V] = { | ||
- | { 55.4830132, | ||
- | { 98.1537399, | ||
- | { | ||
- | { -25.0618916, | ||
- | { 16.7931938, | ||
- | { -47.9787979, | ||
- | }; | ||
- | |||
- | double sec_c2m[M][C] = { | ||
- | { | ||
- | { | ||
- | { | ||
- | { | ||
- | { | ||
- | { | ||
- | }; | ||
- | |||
- | void | ||
- | sec_update_Z (m0, m1, m2, m3, m4, m5) | ||
- | double m0; | ||
- | double m1; | ||
- | double m2; | ||
- | double m3; | ||
- | double m4; | ||
- | double m5; | ||
- | { | ||
- | int m; | ||
- | double mm[M]; | ||
- | |||
- | mm[0] = m0; | ||
- | mm[1] = m1; | ||
- | mm[2] = m2; | ||
- | mm[3] = m3; | ||
- | mm[4] = m4; | ||
- | mm[5] = m5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sec_z[m] = mm[m]; | ||
- | sec_z0[m] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_nelsonCT (m0, m1, m2, m3, m4, m5) | ||
- | double m0; | ||
- | double m1; | ||
- | double m2; | ||
- | double m3; | ||
- | double m4; | ||
- | double m5; | ||
- | { | ||
- | int m; | ||
- | double mm[M]; | ||
- | |||
- | mm[0] = m0; | ||
- | mm[1] = m1; | ||
- | mm[2] = m2; | ||
- | mm[3] = m3; | ||
- | mm[4] = m4; | ||
- | mm[5] = m5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sec_c2m[m][CTC] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_nelsonCL (m0, m1, m2, m3, m4, m5) | ||
- | double m0; | ||
- | double m1; | ||
- | double m2; | ||
- | double m3; | ||
- | double m4; | ||
- | double m5; | ||
- | { | ||
- | int m; | ||
- | double mm[M]; | ||
- | |||
- | mm[0] = m0; | ||
- | mm[1] = m1; | ||
- | mm[2] = m2; | ||
- | mm[3] = m3; | ||
- | mm[4] = m4; | ||
- | mm[5] = m5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sec_c2m[m][CLC] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_nelsonFT (m5) | ||
- | double m5; | ||
- | { | ||
- | sec_c2m[FOCUS][FTC] = m5; | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_nelsonFL (m5) | ||
- | double m5; | ||
- | { | ||
- | sec_c2m[FOCUS][FLC] = m5; | ||
- | } | ||
- | |||
- | void | ||
- | sec_engzero () | ||
- | { | ||
- | int m; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sec_u[m] -= sec_z0[m]-sec_z[m]; | ||
- | sec_z[m] += sec_z0[m]-sec_z[m]; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_userzero () | ||
- | { | ||
- | int m; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sec_z[m] += sec_u[m]; | ||
- | sec_u[m] = 0.0; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_logger (orig, mess) | ||
- | char *orig; | ||
- | char *mess; | ||
- | { | ||
- | void vxcall(); | ||
- | |||
- | vxcall (" | ||
- | } | ||
- | |||
- | int | ||
- | sec_telslewing() | ||
- | { | ||
- | int telslewing = 0; | ||
- | void vxcall(); | ||
- | |||
- | vxcall (" | ||
- | return (telslewing); | ||
- | } | ||
- | |||
- | |||
- | int sec_working; | ||
- | double sec_azimuth; | ||
- | double sec_derotator; | ||
- | double sec_elevation; | ||
- | double sec_temperature; | ||
- | static | ||
- | static | ||
- | |||
- | void | ||
- | sec_update_tl () /* update temperature and elevation */ | ||
- | { | ||
- | void vxcall(); | ||
- | |||
- | vxcall (" | ||
- | vxcall (" | ||
- | vxcall (" | ||
- | vxcall (" | ||
- | } | ||
- | |||
- | void | ||
- | sec_autoreset () | ||
- | { | ||
- | } | ||
- | |||
- | void | ||
- | sec_autofocus_set (status) | ||
- | int | ||
- | { | ||
- | sec_autofocus = status; | ||
- | } | ||
- | |||
- | int | ||
- | sec_autofocus_get () | ||
- | { | ||
- | return (sec_autofocus); | ||
- | } | ||
- | |||
- | void | ||
- | sec_autocoll_set (status) | ||
- | int | ||
- | { | ||
- | sec_autocoll = status; | ||
- | } | ||
- | |||
- | int | ||
- | sec_autocoll_get () | ||
- | { | ||
- | return (sec_autocoll); | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_corr () | ||
- | { | ||
- | int m, c; | ||
- | double | ||
- | double | ||
- | double d[C]; | ||
- | double cos(); | ||
- | |||
- | sec_update_tl (); | ||
- | temp = sec_temperature; | ||
- | cosel = cos(sec_elevation); | ||
- | |||
- | /* sanity checks | ||
- | */ | ||
- | if (sec_min_temp < temp && temp < sec_max_temp) { | ||
- | sec_lastgood_temp = temp; | ||
- | } else { | ||
- | temp = sec_lastgood_temp; | ||
- | } | ||
- | if (sec_min_cosel < cosel && cosel < sec_max_cosel) { | ||
- | sec_lastgood_cosel = cosel; | ||
- | } else { | ||
- | cosel = sec_lastgood_cosel; | ||
- | } | ||
- | |||
- | d[FTC] = sec_autofocus ? temp : 0.0; | ||
- | d[FLC] = sec_autofocus ? cosel : 0.0; | ||
- | d[CTC] = sec_autocoll ? temp : 0.0; | ||
- | d[CLC] = sec_autocoll ? cosel : 0.0; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | sc = 0.0; | ||
- | for (c = 0; c < C; c++) { | ||
- | sc += sec_c2m[m][c] * d[c]; | ||
- | } | ||
- | sec_c[m] = sc; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_calct () /* calculate targets */ | ||
- | { | ||
- | int m, v; | ||
- | double | ||
- | |||
- | for (v = 0; v < V; v++) { | ||
- | t = 0.0; | ||
- | for (m = 0; m < M; m++) { | ||
- | sec_m[m] = sec_u[m]+sec_c[m]+sec_z[m]; | ||
- | t += sec_m2v[v][m] * sec_m[m]; | ||
- | } | ||
- | sec_t[v] = t; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_calcp () /* calculate true positions */ | ||
- | { | ||
- | int m, v; | ||
- | double | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | p = 0.0; | ||
- | for (v = 0; v < V; v++) { | ||
- | p += sec_v2m[m][v] * sec_v[v]; | ||
- | } | ||
- | sec_p[m] = p - sec_z[m]; | ||
- | } | ||
- | } | ||
- | |||
- | int | ||
- | sec_checkMove() | ||
- | { | ||
- | int v; | ||
- | int mstatus = 0; | ||
- | int rstatus = 0; | ||
- | double residual; | ||
- | char errormessage[100]; | ||
- | int strlen(); | ||
- | |||
- | errormessage[0] = 0; | ||
- | for (v = 0; v < V; v++) { | ||
- | residual = sec_t[v]-sec_v[v]; | ||
- | sprintf (errormessage+strlen(errormessage), | ||
- | if (abs(residual) > sec_dv) | ||
- | mstatus = 1; | ||
- | if (abs(residual) > sec_dvmax) | ||
- | rstatus = 1; | ||
- | } | ||
- | if (mstatus) | ||
- | sprintf (sec_errormessage, | ||
- | return (rstatus); | ||
- | } | ||
- | |||
- | void | ||
- | sec_voltsNotOK () | ||
- | { | ||
- | int v; | ||
- | char errormessage[100]; | ||
- | int strlen(); | ||
- | |||
- | errormessage[0] = 0; | ||
- | for (v = 0; v < V; v++) { | ||
- | sprintf (errormessage+strlen(errormessage), | ||
- | } | ||
- | sprintf (sec_errormessage, | ||
- | } | ||
- | |||
- | void | ||
- | sec_sprintf (c, array) | ||
- | char *c; | ||
- | double array[]; | ||
- | { | ||
- | int m; | ||
- | int strlen(); | ||
- | |||
- | *c = 0; | ||
- | for (m = 0; m < M; m++) { | ||
- | sprintf (c+strlen(c), | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_sprintfu (c, array, array0) | ||
- | char *c; | ||
- | double array[]; | ||
- | double array0[]; | ||
- | { | ||
- | int m; | ||
- | int strlen(); | ||
- | |||
- | *c = 0; | ||
- | for (m = 0; m < M; m++) { | ||
- | sprintf (c+strlen(c), | ||
- | array0[m] = array[m]; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_log_servc () | ||
- | { | ||
- | char c[100]; | ||
- | double readmotorcurrent (); | ||
- | |||
- | sprintf (c, " | ||
- | readmotorcurrent (2), readmotorcurrent (3)); | ||
- | sec_logger (" | ||
- | } | ||
- | |||
- | void | ||
- | sec_log () | ||
- | { | ||
- | char c[100]; | ||
- | int strlen(); | ||
- | double cos(); | ||
- | |||
- | sprintf (c, " | ||
- | sec_elevation*57.29577951, | ||
- | cos(sec_elevation), | ||
- | sec_temperature, | ||
- | sec_azimuth*57.29577951, | ||
- | sec_derotator*57.2957795); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_u); | ||
- | sec_sprintfu (c+strlen(c), | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_c); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_z); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_m); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_t); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_v); | ||
- | sec_logger (" | ||
- | sec_sprintf (c, sec_p); | ||
- | sec_logger (" | ||
- | sec_log_servc (); | ||
- | } | ||
- | |||
- | void | ||
- | sec_loop_init () | ||
- | { | ||
- | void getSensors(); | ||
- | int m; | ||
- | |||
- | getSensors (); | ||
- | sec_calcp (); | ||
- | for (m = 0; m < M; m++) { | ||
- | sec_u[m] = sec_p[m]; | ||
- | sec_u0[m] = sec_u[m]; | ||
- | } | ||
- | sec_log (); | ||
- | } | ||
- | |||
- | void | ||
- | sec_loop (timedout) | ||
- | int timedout; | ||
- | { | ||
- | int n; | ||
- | int m; | ||
- | int big; | ||
- | void strcpy(); | ||
- | void getSensors(); | ||
- | |||
- | if (!timedout || ((sec_autofocus||sec_autocoll) && !sec_telslewing())) { | ||
- | sec_working = 1; | ||
- | sec_update_corr (); | ||
- | sec_calct (); | ||
- | if (sec_checkVoltsOK (sec_t)) { | ||
- | getSensors (); | ||
- | sec_calcp (); | ||
- | for (n = 0; n < sec_max_mloops; | ||
- | big = 0; | ||
- | for (m = 0; m < M; m++) { | ||
- | big |= abs(sec_m[m]-sec_z[m]-sec_p[m]) | ||
- | > sec_threshold[m]; | ||
- | } | ||
- | if (!big) | ||
- | break; | ||
- | strcpy (sec_errormessage, | ||
- | movev (sec_t); | ||
- | strcpy (sec_errormessage, | ||
- | getSensors (); | ||
- | sec_calcp (); | ||
- | } | ||
- | if (sec_checkMove ()) { | ||
- | vme8_kill (); | ||
- | } | ||
- | } else { | ||
- | sec_voltsNotOK (); | ||
- | sec_calcp (); | ||
- | } | ||
- | sec_log (); | ||
- | sec_working = 0; | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_printf (id, array) | ||
- | char *id; | ||
- | double array[]; | ||
- | { | ||
- | int m; | ||
- | |||
- | printf (" | ||
- | for (m = 0; m < M; m++) { | ||
- | printf (" %12.6f", | ||
- | } | ||
- | printf (" | ||
- | } | ||
- | |||
- | void | ||
- | sec_printd (id, array) | ||
- | char *id; | ||
- | int array[]; | ||
- | { | ||
- | int m; | ||
- | |||
- | printf (" | ||
- | for (m = 0; m < M; m++) { | ||
- | printf (" %12d", array[m]); | ||
- | } | ||
- | printf (" | ||
- | } | ||
- | |||
- | extern int sec_s[]; | ||
- | |||
- | void | ||
- | sec_print () | ||
- | { | ||
- | printf (" | ||
- | sec_printf (" | ||
- | sec_printf (" | ||
- | sec_printf (" | ||
- | sec_printf (" | ||
- | sec_printf (" | ||
- | sec_printd (" | ||
- | sec_printf (" | ||
- | sec_printf (" | ||
- | sec_errormessage[0] = 0; | ||
- | } | ||
- | |||
- | void | ||
- | telx_log_servc () | ||
- | { | ||
- | sec_log_servc (); | ||
- | } | ||
- | |||
- | void | ||
- | telx_lvdts () | ||
- | { | ||
- | int v; | ||
- | char errormessage[100]; | ||
- | int strlen(); | ||
- | |||
- | errormessage[0] = 0; | ||
- | for (v = 0; v < V; v++) { | ||
- | sprintf (errormessage+strlen(errormessage), | ||
- | } | ||
- | sprintf (sec_errormessage, | ||
- | } | ||
- | |||
- | void | ||
- | telx_rlvdts () | ||
- | { | ||
- | void getSensors(); | ||
- | |||
- | getSensors (); | ||
- | telx_lvdts (); | ||
- | sec_calcp (); | ||
- | sec_log (); | ||
- | } | ||
- | |||
- | void | ||
- | plvdts () | ||
- | { | ||
- | void getSensors(); | ||
- | int v; | ||
- | |||
- | getSensors (); | ||
- | telx_lvdts (); | ||
- | sec_calcp (); | ||
- | |||
- | printf (" | ||
- | for (v = 0; v < V; v++) { | ||
- | printf (" %.4f", sec_v[v]); | ||
- | } | ||
- | printf (" | ||
- | } | ||
- | |||
- | void | ||
- | pmcurr () | ||
- | { | ||
- | double readmotorcurrent (); | ||
- | |||
- | printf (" | ||
- | readmotorcurrent (2), readmotorcurrent (3)); | ||
- | } | ||
- | |||
- | int telvatt_telfocustimeout = 70; | ||
- | int telvatt_telfocuscmdlevel; | ||
- | |||
- | void | ||
- | telvatt_telfocus (c) | ||
- | char *c; | ||
- | { | ||
- | void sleep(); | ||
- | void secondary_trigger(); | ||
- | int sscanf(); | ||
- | double focus; | ||
- | int timeout = telvatt_telfocustimeout; | ||
- | |||
- | if ((telvatt_telfocuscmdlevel > 0) && (sscanf(c," | ||
- | sec_u[FOCUS] = focus; | ||
- | sec_working = 1; | ||
- | secondary_trigger(); | ||
- | while (sec_working && timeout--) | ||
- | sleep (1); | ||
- | } | ||
- | sprintf (c, " | ||
- | } | ||
- | #ifdef OUTOFDATE | ||
- | /* This is an arbitrary zero point for the user motions. | ||
- | * | ||
- | * It was derived using Tom T.'s goodplace lvdt values | ||
- | * and multiplying by the v2m matrix. | ||
- | * { 4.348, -6.021, 5.151, -5.925, 3.126, -5.148 } | ||
- | double | ||
- | 136.6180699, | ||
- | * new values 3/25/97 via cromwell-> | ||
- | double | ||
- | 150.2880699, | ||
- | double | ||
- | 150.2880699, | ||
- | * new values 5/30/97 | ||
- | */ | ||
- | double | ||
- | 26.3139608, | ||
- | double | ||
- | 26.3139608, | ||
- | |||
- | /* Steve West's original matrix | ||
- | {0.0029680, | ||
- | {0.0016000, | ||
- | {0.0029300, | ||
- | {-0.001475, | ||
- | {-0.005346, | ||
- | {-0.0001785, | ||
- | */ | ||
- | |||
- | /* The following matrix of user motions (across) to lvdt voltages (down) | ||
- | * already has the following correction applied. | ||
- | */ | ||
- | |||
- | /* There is correction in dtx and dty when applying focus. There are | ||
- | * 2 reasons: the positioner is mounted slightly tilted wrt to | ||
- | * the primary axis, and the primary comes up on its supports | ||
- | * slightly differently each time causing a small but variable | ||
- | * tilt term. For now, this correction approximates the constant | ||
- | * term for mounting misalignment and the tilt for which the primary supports | ||
- | * usually produce. | ||
- | * dtxSlope = -0.1166667; | ||
- | * dtySlope = 0.0166667; | ||
- | */ | ||
- | |||
- | double sec_m2v[V][M] = { | ||
- | { 0.0029680, | ||
- | { 0.0016000, -0.0007957, -0.0033810, -0.0033320, -0.0058000, -0.0005110, }, | ||
- | { 0.0029300, -0.0050660, -0.0000175, -0.0000407, | ||
- | {-0.0014750, | ||
- | {-0.0053460, | ||
- | {-0.0001785, | ||
- | }; | ||
- | |||
- | /* The following matrix of lvdt voltages (across) to user motions (down) | ||
- | * is the inversion of the above. | ||
- | */ | ||
- | |||
- | double sec_v2m[M][V] = { | ||
- | { 49.8854752, | ||
- | { 98.9533844, | ||
- | { 3.4616475, | ||
- | {-25.0618954, | ||
- | { 16.7931862, -85.4085312, | ||
- | {-47.9788094, | ||
- | }; | ||
- | |||
- | /* The following matrix of (T,L) corrections (across) | ||
- | * {focus_delta_temperature, | ||
- | | ||
- | * to user motion corrections (down) | ||
- | * | ||
- | * These were derived from Cromwell' | ||
- | * for ELCdv and TCdv by multiplying by v2m. | ||
- | * 0.2230000 | ||
- | * 0.2148000 | ||
- | */ | ||
- | |||
- | double sec_c2m[M][C] = { | ||
- | { 0.0, 0.0, 20.3485814, | ||
- | { 0.0, 0.0, 15.6625737, 31.6100656, }, | ||
- | { 0.0, 0.0, | ||
- | { 0.0, 0.0, | ||
- | { 0.0, 0.0, -22.1677258, | ||
- | { 15.0, -120.0, | ||
- | }; | ||
- | |||
- | /* values as of 10/6/97 | ||
- | */ | ||
- | |||
- | double sec_c2m[M][C] = { | ||
- | { 0.0, 0.0, 21.2217299, | ||
- | { 0.0, 0.0, 15.5378383, 31.5126765, }, | ||
- | { 0.0, 0.0, | ||
- | { 0.0, 0.0, | ||
- | { 0.0, 0.0, -22.1677345, | ||
- | { 15.0, -120.0, | ||
- | }; | ||
- | |||
- | |||
- | void | ||
- | sec_update_cromwellB (v0, v1, v2, v3, v4, v5) | ||
- | double v0; | ||
- | double v1; | ||
- | double v2; | ||
- | double v3; | ||
- | double v4; | ||
- | double v5; | ||
- | { | ||
- | int v, m; | ||
- | double vv[V]; | ||
- | double mm[M]; | ||
- | |||
- | vv[0] = v0; | ||
- | vv[1] = v1; | ||
- | vv[2] = v2; | ||
- | vv[3] = v3; | ||
- | vv[4] = v4; | ||
- | vv[5] = v5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | mm[m] = 0.0; | ||
- | for (v = 0; v < V; v++) { | ||
- | mm[m] += sec_v2m[m][v]*vv[v]; | ||
- | } | ||
- | sec_c2m[m][CLC] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_cromwellB0 () | ||
- | { | ||
- | sec_update_cromwellB (0.2230000, | ||
- | -0.0426000, | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_cromwellC (v0, v1, v2, v3, v4, v5) | ||
- | double v0; | ||
- | double v1; | ||
- | double v2; | ||
- | double v3; | ||
- | double v4; | ||
- | double v5; | ||
- | { | ||
- | int v, m; | ||
- | double vv[V]; | ||
- | double mm[M]; | ||
- | |||
- | vv[0] = v0; | ||
- | vv[1] = v1; | ||
- | vv[2] = v2; | ||
- | vv[3] = v3; | ||
- | vv[4] = v4; | ||
- | vv[5] = v5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | mm[m] = 0.0; | ||
- | for (v = 0; v < V; v++) { | ||
- | mm[m] += sec_v2m[m][v]*vv[v]; | ||
- | } | ||
- | sec_c2m[m][CTC] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_cromwellC0 () | ||
- | { | ||
- | sec_update_cromwellC (0.2148000, | ||
- | 0.1717000, | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_cromwellZ (v0, v1, v2, v3, v4, v5) | ||
- | double v0; | ||
- | double v1; | ||
- | double v2; | ||
- | double v3; | ||
- | double v4; | ||
- | double v5; | ||
- | { | ||
- | int v, m; | ||
- | double vv[V]; | ||
- | double mm[M]; | ||
- | |||
- | vv[0] = v0; | ||
- | vv[1] = v1; | ||
- | vv[2] = v2; | ||
- | vv[3] = v3; | ||
- | vv[4] = v4; | ||
- | vv[5] = v5; | ||
- | |||
- | for (m = 0; m < M; m++) { | ||
- | mm[m] = 0.0; | ||
- | for (v = 0; v < V; v++) { | ||
- | mm[m] += sec_v2m[m][v]*vv[v]; | ||
- | } | ||
- | sec_z[m] = mm[m]; | ||
- | sec_z0[m] = mm[m]; | ||
- | printf (" | ||
- | } | ||
- | } | ||
- | |||
- | void | ||
- | sec_update_cromwellZ0 () | ||
- | { | ||
- | sec_update_cromwellZ (0.0, | ||
- | 0.0, | ||
- | } | ||
- | |||
- | /* auto variables */ | ||
- | /* focus versus temperature */ | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | /* focus versus elevation */ | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | /* collimation versus temperature */ | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | /* collimation versus elevation */ | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | double | ||
- | #endif | ||
- | |||
- | </ |