int waveform (int color, int data_file)
{
static char write_buffer[100], read_buffer[10000] ;
int numToRead=10000;
int written_bytes;
////////////////////////////////////////////////
memset(read_buffer, 0, 10000);
ibsic(device);
strcpy (write_buffer, "DATA:STARt 1");
ibwrt (device, write_buffer, strlen(write_buffer));
sprintf (write_buffer, "DATA:STOP 10000");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:MODE SAMPLE");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:STOPAFTER SEQUENCE");
ibwrt (device, write_buffer, strlen(write_buffer));
//read pump intensity, mask type and scan ref
get_intensity();
// Delay(0.5);
strcpy (write_buffer, "ACQUIRE:STATE ON");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "*WAI");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "CURVe?");
ibwrt (device, write_buffer, strlen(write_buffer));
Delay(0.3);
ibrd (device, read_buffer, numToRead);
//Delay(1);
ConvertArrayType (read_buffer, VAL_CHAR, data2fit, VAL_DOUBLE, 10000);
written_bytes=WriteFile (data_file,read_buffer ,10000 );
CloseFile (data_file);
if (written_bytes!=10000)
{
printf("Error writing file!!\n");
}
plot_data(color);
GetCtrlVal (ERG_panel, ERG_panel_fit_live, &j);
// printf ("%d", j);
if (j==1)
{
fit_data ();
}
return 1;
}
int CVICALLBACK Fit_loaded_curve (int panel, int control, int event,
void *callbackData, int eventData1, int eventData2)
{
switch (event)
{
case EVENT_COMMIT:
fit_data();
break;
}
return 0;
}
int waveform (int color, int data_file)
{
static char write_buffer[100];
int numToRead=10000;
char * read_buffer;
read_buffer = malloc (numToRead);
memset(read_buffer, 0, 10000);
ibsic(device);
strcpy (write_buffer, "DATA:STARt 1");
ibwrt (device, write_buffer, strlen(write_buffer));
sprintf (write_buffer, "DATA:STOP 10000");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:MODE SAMPLE");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:STOPAFTER SEQUENCE");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "ACQUIRE:STATE ON");
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "*WAI"); // wait for trigger to continue
ibwrt (device, write_buffer, strlen(write_buffer));
strcpy (write_buffer, "CURVe?");
ibwrt (device, write_buffer, strlen(write_buffer));
Delay(0.3);
ibrd (device, read_buffer, numToRead);
ConvertArrayType (read_buffer, VAL_CHAR, data2fit, VAL_DOUBLE, 10000);
free (read_buffer) ;
plot_data(color);
// check if live-fitting is enabled
GetCtrlVal (Fit_pnl_handle, Fit_panel_fit_live, &fit_status);
if (fit_status==1)
{
fit_data ();
}
return 1;
}
bool rational_fitter_parsec_multi::fit_data(const ptr<data>& dat, ptr<function>& fit, const arguments &args)
{
std::cerr << "Entering first level of fit_data" << std::endl;
ptr<rational_function> r = dynamic_pointer_cast<rational_function>(fit);
const ptr<vertical_segment>& d = dynamic_pointer_cast<vertical_segment>(dat);
if(!r || !d
|| d->confidence_interval_kind() != vertical_segment::ASYMMETRICAL_CONFIDENCE_INTERVAL)
{
std::cerr << "<<ERROR>> not passing the correct class to the fitter" << std::endl;
return false;
}
// I need to set the dimension of the resulting function to be equal
// to the dimension of my fitting problem
// This doesn't work for dimension greater than 1 for now.
//assert( d->dimY() == 1 );
r->setDimX(d->dimX());
r->setDimY(d->dimY());
r->setMin(d->min());
r->setMax(d->max());
std::cout << "<<INFO>> np in [" << _min_np << ", " << _max_np
<< "] & nq in [" << _min_nq << ", " << _max_nq << "]" << std::endl;
const int step = args.get_int("np-step", 1);
int i;
for(i=std::max<int>(2,_min_np); i<=_max_np; i+=step )
{
// double min_delta = std::numeric_limits<double>::max();
// double min_l2_dist= std::numeric_limits<double>::max();
// double mean_delta = 0.0;
// int nb_sol_found = 0;
// int nb_sol_tested = 0;
timer time;
int np;
std::cout << "<<INFO>> fit using np+nq = " << i << std::endl ;
std::cout.flush() ;
time.start();
// i=np+nq => i-1 independant pb
std::cout << r.getcounter() << std::endl;
if(fit_data(d.get(), i-1, r.get(), np))
{
time.stop();
std::cout << r.getcounter() << std::endl;
std::cout << "<<INFO>> got a fit using np = " << np << " & nq = " << i-np << " " << std::endl;
std::cout << "<<INFO>> " << *(r.get()) << std::endl;
std::cout << "<<INFO>> it took " << time << std::endl;
return true;
}
}
std::cerr << "Exiting first level of fit_data" << std::endl;
return false;
}
/*============ INITIAL SETUP ============================*/
fitinfo* setup_models(int *models)
{
static fitinfo fit[MODELS];
static Real incoh_w[1] = {1.}; /* Start with equal weighting */
static model *incoh_m[1];
int i;
fitpars *pars = &fit[0].pars;
fitpars *freepars = &fit[1].pars;
for (i=0; i < MODELS; i++) fit_init(&fit[i]);
fit[0].number_incoherent = 1;
fit[0].incoherent_models = incoh_m;
fit[0].incoherent_weights = incoh_w;
incoh_m[0] = &fit[1].m;
*models = 1;
/* Load the data for each model */
fit_data(&fit[0],"wc02.yor");
fit_data(&fit[1],"wc03.yor");
/* Initialize instrument parameters for each model.*/
for (i=0; i < MODELS; i++) {
const Real L = 5.0042,dLoL=0.020,d=1890.0;
Real Qlo,Tlo, dTlo,dToT,s1,s2;
Qlo=0.0154,Tlo=0.35;
s1=0.21, s2=s1;
dTlo=resolution_dT(s1,s2,d);
dToT=resolution_dToT(s1,s2,d,Tlo);
data_resolution_fv(&fit[i].dataA,L,dLoL,Qlo,dTlo,dToT);
fit[i].beam.lambda = L;
fit[i].beam.background = 1e-10;
interface_create(&fit[i].rm, "erf", erf_interface, 30);
}
/*============= MODEL =====================================*/
/* Add layers: d (thickness, �), rho (Nb, �-2), mu (absorption, �?), rough (interlayer roughness, �) */
for (i=0; i < MODELS; i++) {
model_layer(&fit[i].m, 0.000, 2.07e-6, 0.0e-8, 10.00); /* 0 substrate */
model_layer(&fit[i].m, 12.000, 3.60e-6, 0.0e-8, 10.00); /* 1 oxide */
model_layer(&fit[i].m, 5.800, 3.8e-6, 0.0e-8, 10.00); /* 2 chromium */
model_layer(&fit[i].m, 90.70, 4.50e-6, 0.0e-8, 10.00); /* 3 gold */
model_layer(&fit[i].m, 18.00, 1.00e-6, 0.0e-8, 10.00); /* 4 spacer */
model_layer(&fit[i].m, 14.00, -0.2e-6, 0.0e-8, 10.00); /* 5 alkyl tails */
model_layer(&fit[i].m, 100.0, 6.35e-6, 0.0e-8, 10.00); /* 6 solvent */
}
rho_spacer=0.50e-6;
rho_alkyl=-0.40e-6;
vol_fract_spacer=0.9;
vol_fract_alkyl=0.99;
global_rough=10.0;
/*correct solvent layers for different models*/
/* fit[3].m.d[3] = ... */
fit[1].m.rho[6]=3.4e-6;
/*=============== FIT PARAMETERS ===============================*/
/* Specify which parameters are your fit parameters. Parameters are fitted
* to be the same in all datasets by default
*/
pars_add(pars, "d_oxide", &(fit[0].m.d[1]), 8., 30.);
pars_add(pars, "d_chromium", &(fit[0].m.d[2]), 5., 30.);
pars_add(pars, "rho_chromium", &(fit[0].m.rho[2]), 3.0e-6, 4.5e-6);
pars_add(pars, "rough_cr_au", &(fit[0].m.rough[3]), 5.,30.);
pars_add(pars, "d_gold", &(fit[0].m.d[3]), 40., 150.);
pars_add(pars, "rho_gold", &(fit[0].m.rho[3]), 4.0e-6, 4.5e-6);
pars_add(pars, "d_spacer", &(fit[0].m.d[4]), 10., 30.);
pars_add(pars, "rho_spacer", &(rho_spacer), 0e-6, 0.5e-6);
pars_add(pars, "vol_fract_spacer", &(vol_fract_spacer), 0., 1.);
pars_add(pars, "d_alkyl", &(fit[0].m.d[5]), 10., 17.);
pars_add(pars, "rho_alkyl", &(rho_alkyl), -0.5e-6, 0.0e-6);
pars_add(pars, "vol_fract_alkyl", &(vol_fract_alkyl), 0., 1.);
pars_add(pars, "rho_solv_0", &(fit[0].m.rho[fit[0].m.n-1]), 6.0e-6, 6.35e-6);
pars_add(pars, "rho_solv_1", &(fit[1].m.rho[fit[1].m.n-1]), 3.0e-6, 4.5e-6);
pars_add(pars, "global_rough", &(global_rough), 8.0, 15.0);
pars_add(pars, "model_weight",&(incoh_w[0]), 0., 1.);
/* Build a list of 'free parameters' in fit[1].pars. These are
* parameters for which the values are aloowed to differ from those
* in model 0. By default all values in all models are the same unless
* specified here. The range data is not useful, so set it to [0,1].
*/
pars_add(freepars, "rho_solv_1", &(fit[1].m.rho[fit[1].m.n-1]), 0., 1.);
pars_add(freepars, "rough_cr_au", &(fit[0].m.rough[3]), 0., 1.);
constraints = constr_models;
return fit;
}
