/*--------------------------------------------------------------------------------*/ size_t get_burst_nextra(size_t ndata2, int depth) { size_t nchan=get_nchan_from_depth(depth); size_t nextra=nchan; if (nextra>ndata2) nextra=ndata2; return nextra; }
/*--------------------------------------------------------------------------------*/ float get_diagonal_dm_simple(float nu1, float nu2, float dt, int depth) { float d1=1.0/nu1/nu1; float d2=1.0/nu2/nu2; int nchan=get_nchan_from_depth(depth); //printf("nchan is %d from %d\n",nchan,depth); //printf("freqs are %12.4f %12.4f\n",nu1,nu2); float dm_max=dt/DM0/( (d2-d1)/nchan); //printf("current dm is %12.4f\n",dm_max); return fabs(dm_max); }
/*--------------------------------------------------------------------------------*/ float get_diagonal_dm_simple(float nu1, float nu2, float dt, int depth, float disp_ind) { float d1=pow(1.0/nu1,disp_ind); float d2=pow(1.0/nu2,disp_ind); int nchan=get_nchan_from_depth(depth); //printf("nchan is %d from %d\n",nchan,depth); //printf("freqs are %12.4f %12.4f\n",nu1,nu2); float dm_max= ((dt*nchan)/DM0)/(d2-d1); //printf("current dm is %12.4f\n",dm_max); return fabs(dm_max); }
Data *put_data_into_burst_struct(float *indata, size_t ntime, size_t nfreq, size_t *chan_map, int depth) { Data *dat=(Data *)calloc(1,sizeof(Data)); dat->raw_nchan=nfreq; int nchan=get_nchan_from_depth(depth); dat->nchan=nchan; //int nextra=get_burst_nextra(ntime2,depth); dat->ndata=ntime; dat->raw_data=matrix(dat->raw_nchan,dat->ndata); dat->chan_map=chan_map; dat->data=matrix(dat->nchan,dat->ndata); copy_in_data(dat,indata,ntime); return dat; }
/*--------------------------------------------------------------------------------*/ Data *put_data_into_burst_struct(float *indata1, float *indata2, size_t ntime1, size_t ntime2, size_t nfreq, size_t *chan_map, int depth) { Data *dat=(Data *)calloc(1,sizeof(Data)); dat->raw_nchan=nfreq; int nchan=get_nchan_from_depth(depth); //printf("expecting %d channels.\n",nchan); dat->nchan=nchan; int nextra=get_burst_nextra(ntime2,depth); dat->ndata=ntime1+nextra; dat->raw_data=matrix(dat->raw_nchan,dat->ndata); dat->chan_map=chan_map; dat->data=matrix(dat->nchan,dat->ndata); copy_in_data(dat,indata1,ntime1,indata2,ntime2); return dat; }
// If chan_map is an array of indeces, should it not be typed `size_t *`? -KM void burst_setup_channel_mapping(CM_DTYPE *chan_map, size_t nfreq, float freq0, float delta_f, int depth) { int nchan=get_nchan_from_depth(depth); int i,j; float l0=1.0/(freq0+0.5*delta_f); l0=l0*l0; float l1=1.0/(freq0+(nfreq-0.5)*delta_f); l1=l1*l1; if (l0>l1) { float tmp=l0; l0=l1; l1=tmp; } float *out_chans=(float *)malloc(sizeof(float)*nchan); float dl=(l1-l0)/(nchan-1); for (i=0;i<nchan;i++) out_chans[i]=l0+dl*i; for (i=0;i<nfreq;i++) { float myl=1.0/(freq0+(0.5+i)*delta_f); myl=myl*myl; int jmin=-1; float minerr=1e30; for (j=0;j<nchan;j++) { float curerr=fabs(myl-out_chans[j]); if (curerr<minerr) { minerr=curerr; jmin=j; } } chan_map[i]=jmin; } }
// For allocating output buffer. size_t burst_get_num_dispersions(size_t nfreq, float freq0, float delta_f, int depth) { return get_nchan_from_depth(depth); }
void add_to_ring(DTYPE* indata, DTYPE* outdata, CM_DTYPE* chan_map, DTYPE* ring_buffer_data, int ringt0, int chunk_size, int ring_length, float delta_t, size_t nfreq, float freq0, float delta_f, int depth) { omp_set_dynamic(0); omp_set_num_threads(8); //zero-pad data int ndm = get_nchan_from_depth(depth); float * indata_pad = (float*)malloc(sizeof(float)*nfreq*(chunk_size + ndm)); for(int i = 0; i < nfreq; i++){ memcpy(indata_pad + i*(chunk_size + ndm), indata + i*chunk_size,sizeof(float)*chunk_size); memset(indata_pad + i*(chunk_size + ndm) + chunk_size,0,sizeof(float)*(ndm)); } Data *dat=put_data_into_burst_struct(indata_pad,chunk_size + ndm,nfreq,chan_map,depth); remap_data(dat); int nchan = dat->nchan; float** ring_buffer = (float**)malloc(sizeof(float*)*nchan); make_rect_mat(ring_buffer,ring_buffer_data,nchan,ring_length); //allocate the triangular matrix for output //float* tmp = malloc((nchan*chunk_size + (nchan*(nchan - 1))/2)*sizeof(float)); //float* tmp = (float*)malloc(nchan*(chunk_size + nchan)*sizeof(float)); //float** tmp_mat = (float**)malloc(nchan*sizeof(float*)); //make_triangular_mat(tmp_mat,tmp,nchan,chunk_size,1); //make_rect_mat(tmp_mat, tmp, nchan, chunk_size + nchan); float** tmp_mat = matrix(nchan,chunk_size + nchan); dedisperse_lagged(dat->data,tmp_mat,nchan,chunk_size); //printf("ringt0: %i\n",ringt0); update_ring_buffer(tmp_mat,ring_buffer,nchan,chunk_size,ring_length,&ringt0); //printf("ringt0: %i\n",ringt0); //probably not the most efficient way to use the output array //does not stop copying if data is incomplete //does not prevent overlap //ring buffer must be long enough //because of the search padding requirement... for(int i = 0; i < nchan; i++){ int src0 = (ring_length + ringt0 - i) % ring_length; int src1 = (ring_length + ringt0 + chunk_size - i) % ring_length; //printf("ring length %i, cs %i\n",ring_length,chunk_size); //printf("i: %i, src0: %i, src1 %i\n",i,src0,src1); if (src1 < src0){ int first_cpy = (ring_length - src0); int second_cpy = chunk_size - first_cpy; memcpy(outdata + i*(chunk_size + nchan), ring_buffer[i] + src0, first_cpy*sizeof(float)); memcpy(outdata + i*(chunk_size + nchan) + first_cpy, ring_buffer[i] + src0 + first_cpy, (second_cpy)*sizeof(float)); } else{ memcpy(outdata + i*(chunk_size + nchan), ring_buffer[i] + src0, (chunk_size)*sizeof(float)); } } free(dat->data[0]); free(dat->data); free(dat->raw_data[0]); free(dat->raw_data); free(dat); //free(tmp); free(indata_pad); //free(tmp_mat[0]); free(tmp_mat[0]); free(tmp_mat); //free(ring_buffer); }