/*--------------------------------------------------------------------------------*/
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);
}
