static void free_outputs(list_t *outputs) {
int i;
for (i = 0; i < outputs->length; ++i) {
free_output(outputs->items[i]);
}
list_free(outputs);
}
/* Free any allocated data in the struct */
static void free_nb_struct(struct object *obj) {
DERR(fprintf(stderr, "Freeing storage.\n"));
while(THIS->inputs != NULL) {
free_input(THIS->inputs);
}
if(THIS->outp != NULL) {
free_output(THIS->outp);
THIS->outp = NULL;
}
free_data_buf();
free_svalue(&THIS->args);
free_svalue(&THIS->cb);
THIS->cb.type = T_INT;
THIS->args.type = T_INT;
}
/* Set the output file (file object) */
static void f_output(INT32 args) {
if(args) {
if(ARG(1).type != T_OBJECT) {
SIMPLE_BAD_ARG_ERROR("_Caudium.nbio()->output", 1, "object");
} else {
output *outp;
if(THIS->outp != NULL) {
free_output(THIS->outp);
THIS->outp = NULL;
}
outp = malloc(sizeof(output));
outp->file = ARG(1).u.object;
outp->fd = fd_from_object(outp->file);
outp->set_nb_off = find_identifier("set_nonblocking", outp->file->prog);
outp->set_b_off = find_identifier("set_blocking", outp->file->prog);
outp->write_off = find_identifier("write", outp->file->prog);
if (outp->write_off < 0 || outp->set_nb_off < 0 || outp->set_b_off < 0)
{
free(outp);
Pike_error("_Caudium.nbio()->output: illegal file object%s%s%s\n",
((outp->write_off < 0)?"; no write":""),
((outp->set_nb_off < 0)?"; no set_nonblocking":""),
((outp->set_b_off < 0)?"; no set_blocking":""));
}
DERR(fprintf(stderr, "New output (fd = %d)\n", outp->fd));
outp->mode = ACTIVE;
add_ref(outp->file);
THIS->outp = outp;
noutputs++;
/* Set up the read callback. We don't need a close callback since
* it never will be called w/o a read_callback (which we don't want one).
*/
set_outp_write_cb(outp);
}
} else {
SIMPLE_TOO_FEW_ARGS_ERROR("_Caudium.nbio()->output", 1);
}
pop_n_elems(args-1);
}
void bar_teardown(struct bar *bar) {
free_config(bar->config);
free_output(bar->output);
free_status_line(bar->status);
/* close sockets/pipes */
if (bar->status_read_fd) {
close(bar->status_read_fd);
}
if (bar->ipc_socketfd) {
close(bar->ipc_socketfd);
}
if (bar->ipc_event_socketfd) {
close(bar->ipc_event_socketfd);
}
/* terminate status command process */
terminate_status_command(bar->status_command_pid);
}
/* Called when the sending is finished. Either due to broken connection
* or no more data to send.
*/
static void finished(void)
{
DERR(fprintf(stderr, "Done writing (%d sent)\n", (INT32)THIS->written));
THIS->finished = 1;
while(THIS->inputs != NULL) {
free_input(THIS->inputs);
}
if(THIS->outp != NULL) {
free_output(THIS->outp);
THIS->outp = NULL;
}
if(THIS->cb.type != T_INT)
{
DERR(fprintf(stderr, "Calling done callback\n"));
push_svalue(&(THIS->args));
apply_svalue(&(THIS->cb),1);
pop_stack();
}
}
// this function is called by the FORTRAN part of ATLAS
int fit_wrapper_ (double *spec_f, int *ntheta_f, int *nk_f, int *nnu_f, double *delta_k_f, double *delta_nu_f,
char *fname_guess, int *verbose_f, int *nmodes, float *dataout, int *narr, int *karr, int *kstart, int *kend)
{
FILE *fp;
int retval, ii, ij, junk, printback, verbose, ntheta, nk, nnu, ind;
double delta_k, delta_nu, ***spec;
int nummodes, *guess_k;
double *guess_freq, *guess_amp, *guess_width;
cl_tag tag;
// file names
char fname_pspec[FNAMELEN], fname_output[FNAMELEN];
char fname_back[FNAMELEN];
inputs inp; // struct containing all of the inputs for mrf
outputs outp; // struct containing all of the outputs
verbose = *verbose_f;
ntheta = *ntheta_f;
nk = *nk_f;
nnu = *nnu_f;
delta_k = *delta_k_f;
delta_nu = *delta_nu_f;
// make room for spectrum
ind = 0;
spec = (double***) malloc(nnu*sizeof(double**));
for (ii=0; ii<nnu; ii++)
{
spec[ii] = (double**) malloc(nk*sizeof(double*));
for (ij=0; ij<nk; ij++)
{
spec[ii][ij] = (double*) malloc(ntheta*sizeof(double));
if (spec[ii][ij]==NULL)
{
printf("Error allocating memory.\n");
return EXIT_FAILURE;
} else {
memcpy(spec[ii][ij], &(spec_f[ind]), ntheta*sizeof(double));
ind += ntheta;
}
}
}
// load power spectrum data into input struct
inp.pspec = spec;
inp.pspec_ntheta = ntheta;
inp.pspec_nk = nk;
inp.pspec_nnu = nnu;
inp.pspec_delta_k = delta_k;
inp.pspec_delta_nu = delta_nu;
// tell code that it needs to convert a pspec in log-power, kx-ky to one of linear-power, tht-k
inp.convert_cart_polar = 0;
// read a guess table
//retval = read_model_file_testing ("16_deg.model", &nummodes, &guess_k, &guess_freq, &guess_amp, &guess_width, verbose);
nummodes = guess_table_num;
guess_k = (int*) malloc(nummodes * sizeof(int));
guess_freq = (double*) malloc(nummodes * sizeof(double));
guess_amp = (double*) malloc(nummodes * sizeof(double));
guess_width = (double*) malloc(nummodes * sizeof(double));
memcpy(guess_k, guess_table_k, nummodes * sizeof(int));
memcpy(guess_freq, guess_table_freq, nummodes * sizeof(double));
memcpy(guess_amp, guess_table_amp, nummodes * sizeof(double));
memcpy(guess_width, guess_table_width, nummodes * sizeof(double));
// load guess table into input struct
inp.guess_nummodes = nummodes;
inp.guess_k = guess_k; // wavenumber index
inp.guess_freq = guess_freq;
inp.guess_amp = guess_amp;
inp.guess_width = guess_width;
// set up run parameters
// check meanings in interface.h
inp.verbose = 0;//verbose;
inp.dofits = 1;
inp.fit_above = 2;
inp.ac_cutoff = 4500.0;
inp.detect_ridge = 1.;
inp.kstart = *kstart;
inp.kend = *kend;
inp.ftol = 1e-8;
inp.xtol = 1e-4;
inp.gtol = 1e-8;
inp.niter = 400;
inp.output_covar = 0;
// recording the entire covariance matrix is a pain
// mostly from a data organization perspective
// call fitting procedure
if (verbose) printf("Calling fitting.. (%d-%d)\n", *kstart, *kend);
mrf_fit(&inp, &outp);
if (verbose) printf("Done fitting.\n");
// do something with outputs
if (verbose) printf("Total Modes Fit between (%d-%d) = %d\n", *kstart, *kend, outp.nummodes);
*nmodes = outp.nummodes;
for (ii=0; ii<outp.nummodes; ii++)
{
(narr)[ii] = outp.mode_n[ii];
(karr)[ii] = outp.mode_k[ii];
(dataout)[ii*4+0] = outp.mode_ux[ii];
(dataout)[ii*4+1] = outp.mode_err_ux[ii];
(dataout)[ii*4+2] = outp.mode_uy[ii];
(dataout)[ii*4+3] = outp.mode_err_uy[ii];
}
/*fp = fopen(fname_output, "w");
for (ii=0; ii<outp.nummodes; ii++)
{
// obviously there are more parameters that can be printed
// check interface.h, outputs struct for all of the mode_* parameters
fprintf(fp, "%d\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%e\t%d\t%d\t%d\n",
outp.mode_k[ii],
(outp.mode_k[ii]+1)*delta_k, // the wavenumber in Mm^-1
outp.mode_freq[ii] / ((outp.mode_k[ii]+1)*delta_k),
outp.mode_freq[ii], outp.mode_err_freq[ii],
outp.mode_amp[ii], outp.mode_err_amp[ii],
outp.mode_width[ii], outp.mode_err_width[ii],
outp.mode_ux[ii], outp.mode_err_ux[ii],
outp.mode_uy[ii], outp.mode_err_uy[ii],
outp.mode_fanis[ii], outp.mode_err_fanis[ii],
outp.mode_thtanis[ii], outp.mode_err_thtanis[ii],
0.0, 0.0,
outp.mode_n[ii],
outp.mode_mpreturn[ii], // return code from optimization. used for data culling
outp.mode_failure[ii]); // failure mode tag. also used for culling
}
fclose(fp);
*/
// free memory? probably important..
// TODO: free memory...
free_output(&outp);
free(guess_k);
free(guess_freq);
free(guess_amp);
free(guess_width);
return 0;
}
