VARRAY *new_varray(int item_size)
{
VARRAY *v;
v=do_alloc(1, sizeof(*v));
v->item_size=item_size;
v->free=0;
v->size=100;
v->data=do_alloc(v->size, v->item_size);
return v;
}
SPARSE_CONV *new_sparse_conv(void)
{
SPARSE_CONV *sc;
sc=do_alloc(1, sizeof(*sc));
sc->free=0;
sc->size=40;
sc->bin=do_alloc(sc->size, sizeof(*sc->bin));
sc->data=do_alloc(sc->size, sizeof(*sc->data));
return(sc);
}
int main() {
struct Reap r[10];
char names[10][10];
int i=0, j=0;
srand(100);
for(i=0;i<10;i++) {
sprintf(names[i], "reap%d", i);
r[i].counter = 0;
r[i].h = _new_reap(names[i]);
r[i].p = NULL;
}
for(j=0;j<10;j++){
printf("********************ROUND %d********************\n", j);
for(i=0;i<10;i++){
if(((rand() % 10) < 2) && r[i].counter > 20){
printf("Freeing reap %d!!!!!!!!!!!!!!", i);
_free_reap(&r[i].h);
r[i].counter = -1;
}
if(r[i].counter >= 0)
do_alloc(&r[i]);
}
}
fprintf(stdout, "ok\n");
return 0;
}
void extract_acpi(void)
{
int id = fw_cfg_file_id("etc/table-loader");
int n = fw_cfg_file_size(id);
struct loader_cmd script[n / sizeof(struct loader_cmd)];
int i;
if (!n)
return;
fw_cfg_read_file(id, script, n);
for (i = 0; i < ARRAY_SIZE(script); i++) {
struct loader_cmd *s = &script[i];
switch(script[i].cmd) {
case CMD_ALLOC:
do_alloc(s->alloc.file, s->alloc.align, s->alloc.zone);
break;
case CMD_PTR:
do_ptr(s->ptr.dest, s->ptr.src, s->ptr.offset, s->ptr.size);
break;
case CMD_CHECKSUM:
do_checksum(s->checksum.file, s->checksum.offset,
s->checksum.start, s->checksum.len);
break;
case CMD_QUIT:
return;
default:
panic();
}
}
}
int main(int argc, char *argv[])
{
int lc;
tst_parse_opts(argc, argv, NULL, NULL);
#if __WORDSIZE == 32
tst_brkm(TCONF, NULL, "test is not designed for 32-bit system.");
#endif
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
init_meminfo();
switch (pid = fork()) {
case -1:
tst_brkm(TBROK | TERRNO, cleanup, "fork");
case 0:
do_alloc();
exit(0);
default:
check_swapping();
}
}
cleanup();
tst_exit();
}
void expand_jobs(void)
{
JOB *p;
jobs_size=2*jobs_size+10;
p=do_alloc(jobs_size, sizeof(JOB));
if(jobs_free>0)memcpy(p, job, jobs_free*sizeof(JOB));
free(job);
job=p;
}
/* instead of having per-skypatch
we simply discard a SFTs which contribute less than a certain fraction of weight in each dataset */
void assign_cutoff_veto(void)
{
int i,k,m;
WEIGHT_INFO *w;
double total_weight, accum_weight, a;
DATASET *d;
w=do_alloc(nsegments, sizeof(*w));
m=0;
total_weight=0.0;
for(k=0;k<d_free;k++) {
d=&(datasets[k]);
for(i=0;i<d->free;i++) {
if(d->sft_veto[i] && d->sft_veto[i]!=3)continue;
w[m].dataset=k;
w[m].segment=i;
a=d->expTMedians[i]*d->weight;
total_weight+=a;
w[m].weight=a;
m++;
}
}
if(m<1) {
fprintf(stderr, "No clean SFTs found, skipping veto\n");
fprintf(LOG, "No clean SFTs found, skipping veto\n");
return;
}
//fprintf(stderr, "%d %d\n", m, nsegments);
qsort(w, m, sizeof(*w), weight_cmp);
//fprintf(stderr, "%g %g %g ... %g %g %g\n", w[0].weight, w[1].weight, w[2].weight, w[m-3].weight, w[m-2].weight, w[m-1].weight);accum_weight=0;
accum_weight=0;
for(i=0;i<m;i++) {
accum_weight+=w[i].weight;
if(accum_weight>args_info.weight_cutoff_fraction_arg*total_weight)break;
datasets[w[i].dataset].sft_veto[w[i].segment]=3;
}
accum_weight-=w[i].weight;
fprintf(stderr, "Vetoed %d sfts (out of %d, %f ratio) with %g weight out of %g total weight (%f fraction)\n",
i, nsegments, (i*1.0)/nsegments, accum_weight, total_weight, accum_weight/total_weight);
fprintf(LOG, "Vetoed %d sfts (out of %d, %f ratio) with %g weight out of %g total weight (%f fraction)\n",
i, nsegments, (i*1.0)/nsegments, accum_weight, total_weight, accum_weight/total_weight);
for(k=0;k<d_free;k++) {
d=&(datasets[k]);
m=0;
for(i=0;i<d->free;i++) {
if(d->sft_veto[i])continue;
m++;
}
fprintf(stderr, "Dataset %s has %d clean sfts (%f ratio)\n", d->name, m, (1.0*m)/d->free);
}
free(w);
}
SEGMENT_INFO *find_segments(double gps_start, double gps_end, int veto_mask, int *count)
{
SEGMENT_INFO *r, *p;
int length=(gps_end-gps_start)/450+1; /* this is enough for two ifos */
int i, k;
DATASET *d;
*count=0;
r=do_alloc(length, sizeof(*r));
for(k=0;k<d_free;k++) {
d=&(datasets[k]);
for(i=0;i<d->free;i++) {
if(d->sft_veto[i] & ~veto_mask)continue;
if(d->gps[i]<gps_start)continue;
if(d->gps[i]>=gps_end)continue;
if(*count>=length) {
length*=2;
p=do_alloc(length, sizeof(*p));
if(*count>0)memcpy(p, r, (*count) * sizeof(*p));
free(r);
r=p;
}
r[*count].gps=d->gps[i];
r[*count].detector_velocity[0]=d->detector_velocity[3*i];
r[*count].detector_velocity[1]=d->detector_velocity[3*i+1];
r[*count].detector_velocity[2]=d->detector_velocity[3*i+2];
r[*count].coherence_time=d->coherence_time;
r[*count].dataset=k;
r[*count].segment=i;
r[*count].f_plus=NAN;
r[*count].f_cross=NAN;
r[*count].bin_shift=NAN;
r[*count].diff_bin_shift=NAN;
(*count)++;
}
}
return(r);
}
static void
new_quote(Quote * q, const char *s)
{
DPRINTF(("new_quote(%s=\"%s\")\n", whichQuote(q), s));
q->used = strlen(s);
q->text = do_alloc(q->text, q->used, &(q->have));
if (q->text != 0)
strcpy(q->text, s);
}
/*
* The flt_bfr_*() functions are used for managing a possibly multi-line buffer
* that will be written as one attributed region.
*/
void
flt_bfr_append(const char *text, int length)
{
flt_bfr_text = do_alloc(flt_bfr_text, flt_bfr_used + (size_t) length, &flt_bfr_size);
if (flt_bfr_text != 0) {
strncpy(flt_bfr_text + flt_bfr_used, text, (size_t) length);
flt_bfr_used += (unsigned) length;
} else {
CannotAllocate("flt_bfr_append");
}
}
void init_jobs(void)
{
jobs_free=0;
jobs_size=100;
job=do_alloc(jobs_size, sizeof(JOB));
jobs_submitted=0;
jobs_done=0;
next_job_to_do=0;
thread_mutex_init(&jobs_mutex);
thread_cond_init(&wait_for_more_jobs_condition);
thread_cond_init(&all_done_condition);
}
void* myalloc(size_t len)
{
ALIGN8(len);
size_t i = ind(len);
if (i != MEM_SIZ_LARGE)
{
return do_alloc(i);
}
else
{
return do_alloc_large(len);
}
}
void put_partial_power_sum_F(SUMMING_CONTEXT *ctx, PARTIAL_POWER_SUM_F *pps)
{
PARTIAL_POWER_SUM_F ** p;
if(ctx->pps_pool_free>=ctx->pps_pool_size) {
ctx->pps_pool_size*=2;
p=do_alloc(ctx->pps_pool_size, sizeof(*ctx->partial_power_sum_pool));
memcpy(p, ctx->partial_power_sum_pool, ctx->pps_pool_free*sizeof(*ctx->partial_power_sum_pool));
free(ctx->partial_power_sum_pool);
ctx->partial_power_sum_pool=p;
}
ctx->partial_power_sum_pool[ctx->pps_pool_free]=pps;
ctx->pps_pool_free++;
}
int main(int argc, char *argv[])
{
FILE *fin;
int i;
float a;
LOG=stderr;
if(argc<7){
fprintf(stderr, "\nUsage: %s mode resolution lower_cut upper_cut file.dat skymap.png\n", argv[0]);
fprintf(stderr, "\tmodes: plain, log10\n");
fprintf(stderr, "\tcutoff: number or \"auto\"\n\n");
return -1;
}
resolution=atof(argv[2]);
fin=fopen(argv[5], "r");
if(fin==NULL){
perror("Cannot read file:");
return -1;
}
grid=make_sin_theta_grid(resolution);
data=do_alloc(grid->npoints, sizeof(*data));
fread(data, sizeof(*data), grid->npoints, fin);
fprintf(stderr, "%g %g %g %g\n", data[0], data[1], data[2], data[3]);
if(!strcasecmp(argv[1], "log10")){
for(i=0;i<grid->npoints;i++)data[i]=log10(data[i]);
}
if(strcasecmp(argv[3], "auto")){
a=atof(argv[3]);
for(i=0;i<grid->npoints;i++)
if(data[i]<=a)data[i]=a;
}
if(strcasecmp(argv[4], "auto")){
a=atof(argv[4]);
for(i=0;i<grid->npoints;i++)
if(data[i]>=a)data[i]=a;
}
pic=make_RGBPic(grid->max_n_ra+140, grid->max_n_dec);
plot_grid_f(pic, grid, data, 1);
RGBPic_dump_png(argv[6], pic);
return 0;
}
int varray_add(VARRAY *v, void *item)
{
if(v->free>=v->size) {
void *p;
v->size=2*v->size+10;
p=do_alloc(v->size, v->item_size);
if(v->free>0)memcpy(p, v->data, v->free*v->item_size);
if(v->data!=NULL)free(v->data);
v->data=p;
}
memcpy(& ((((char *)(v->data))[v->free*v->item_size])), item, v->item_size);
v->free++;
return(v->free-1);
}
void add_suppress_region(double line1, double line2, int N)
{
LINE_SUPPRESS_REGION *p;
if(sl_free>=sl_size){
sl_size=2*sl_size+10;
p=do_alloc(sl_size, sizeof(*p));
if(sl_free>0)memcpy(p, suppress_lines, sl_free*sizeof(*suppress_lines));
if(suppress_lines!=NULL)free(suppress_lines);
suppress_lines=p;
}
suppress_lines[sl_free].line1=line1;
suppress_lines[sl_free].line2=line2;
suppress_lines[sl_free].N=N;
sl_free++;
}
REAL8 sum_r8_squares(REAL8 *array, long count)
{
int i,c;
REAL8 *squares, a;
squares=do_alloc(count, sizeof(*squares));
for(i=0;i<count;i++)squares[i]=array[i]*array[i];
qsort(squares, count, sizeof(*squares), c_r8);
c=count;
while(c>1){
for(i=0;(i+2)<=c;i+=2){
squares[i>>1]=squares[i]+squares[i+1];
}
if(c & 1){
squares[(c>>1)]=squares[c-1];
c=(c>>1)+1;
} else {
static void test_swapping(void)
{
#if __WORDSIZE == 32
tst_brk(TCONF, "test is not designed for 32-bit system.");
#endif
init_meminfo();
switch (pid = SAFE_FORK()) {
case 0:
do_alloc();
exit(0);
default:
check_swapping();
}
}
void init_threads(int mt)
{
max_threads=mt-1;
if(max_threads<0) {
max_threads=cpu_count()-1;
}
if(max_threads<0) max_threads=0;
thread_id=do_alloc(max_threads, sizeof(*thread_id));
num_threads=0;
threads_started=0;
thread_cond_init(&thread_not_needed);
thread_mutex_init(&thread_num_mutex);
set_concurrency(1);
fprintf(stderr, "maximum threads: %d\n", max_threads+1);
fprintf(LOG, "maximum threads: %d\n", max_threads+1);
}
void log_extremes_viterbi(SUMMING_CONTEXT *ctx, int pi, POWER_SUM **ps, int count)
{
int i,j,k,m,r, lm;
POINT_STATS pst;
POWER_SUM_STATS *stats;
float *tmp;
float *tmp2a, *tmp2b, *tmp_min_weight, *tmp_max_weight;
float *p1, *p2, *p3, *p4, *p5;
float min_weight, max_weight, inv_weight, weight, *total_weight;
int fshift_count=args_info.nfshift_arg; /* number of frequency offsets */
int shift;
long tmp_stride=(useful_bins+(ALIGNMENT-1)) & (~(ALIGNMENT-1));
long tmp_size;
if(args_info.filter_lines_arg) {
/* To fix this we would need to pass and process per-frequency weight arrays. This needs to be done carefully to maintain efficiency
* The code will work as is if this is disabled, using an approximation to true weight.
* But the checks that enough weight was accumulated to compute power will not work */
fprintf(stderr, "*** ERROR: viterbi filtering is incompatible with filter-lines=1\n");
exit(-1);
}
/* size of tmp array */
tmp_size=args_info.nchunks_arg*veto_free*fshift_count*tmp_stride*sizeof(float);
/* size of tmp2 arrays */
tmp_size+=2*(tmp_stride*fshift_count)*sizeof(float);
/* size of stats array */
tmp_size+=nei*count*sizeof(*stats)+ALIGNMENT;
/* sizes of tmp_min_weight and tmp_max_weight arrays */
tmp_size+=2*args_info.nchunks_arg*veto_free*fshift_count*sizeof(float)+2*ALIGNMENT;
/* sizes of total_weight array */
tmp_size+=fshift_count*sizeof(float)+2*ALIGNMENT;
if(ctx->log_extremes_pstats_scratch_size<tmp_size) {
free(ctx->log_extremes_pstats_scratch);
ctx->log_extremes_pstats_scratch_size=tmp_size;
ctx->log_extremes_pstats_scratch=do_alloc(1, tmp_size);
p1=(float *)ctx->log_extremes_pstats_scratch;
PRAGMA_IVDEP
for(i=0;i<(ctx->log_extremes_pstats_scratch_size/sizeof(*p1));i++)p1[i]=NAN;
fprintf(stderr, "Expanded log_extremes_pstats_scratch to %f MB nchunks=%d veto_free=%d count=%d nei=%d\n", ctx->log_extremes_pstats_scratch_size*1e-6, args_info.nchunks_arg, veto_free, count, nei);
}
void add_fake_data_command(int command, double phase, double frequency, double amplitude)
{
FAKE_DATA_COMMAND *p;
int i;
if(fake_data_free>=fake_data_size){
fake_data_size=2*fake_data_size+10;
p=do_alloc(fake_data_size, sizeof(FAKE_DATA_COMMAND));
if(fake_data_free>0)memcpy(p, fake_data, fake_data_free*sizeof(FAKE_DATA_COMMAND));
if(fake_data!=NULL)free(fake_data);
fake_data=p;
}
i=fake_data_free;
fake_data_free++;
fake_data[i].command=command;
fake_data[i].phase=phase;
fake_data[i].frequency=frequency;
fake_data[i].amplitude=amplitude;
}
void* buddy_alloc(buddy_t* pb, size_t size)
{
int ind = size_parse(size);
if (ind == -1)
{
fprintf(stderr, "wrong alloc size: %d\n", size);
return NULL;
}
node_t** ppn = do_alloc(pb, ind);
if (!ppn)
{
fprintf(stderr, "not enough free space\n");
return NULL;
}
else
{
return (*ppn)->addr;
}
}
void create_segments(EXTREME_INFO ***out_ei, int *out_nei)
{
int i, k, m, nei;
EXTREME_INFO **ei;
ei=do_alloc(args_info.nchunks_arg*(args_info.nchunks_arg+1)*(veto_free+1)/2, sizeof(*ei));
fprintf(LOG, "nchunks: %d\n", args_info.nchunks_arg);
fprintf(LOG, "nchunks refinement: %d\n", args_info.nchunks_refinement_arg);
fprintf(LOG, "min nchunks: %d\n", args_info.min_nchunks_arg);
fprintf(LOG, "veto_free: %d\n", veto_free);
nei=0;
for(i=0;i<args_info.nchunks_arg;i+=args_info.nchunks_refinement_arg)
for(k=0;k< args_info.nchunks_arg-i;k+=args_info.nchunks_refinement_arg) {
if(k+1<args_info.min_nchunks_arg)continue;
for(m=-1;m<veto_free;m++) {
if(m<0) {
if((veto_free<=1) && args_info.split_ifos_arg)continue; /* if there is only one detector no reason to compute "all" twice */
snprintf(s, 19999, "%d_%d_all", i/args_info.nchunks_refinement_arg, (i+k)/args_info.nchunks_refinement_arg);
} else {
if(!args_info.split_ifos_arg)continue; /* combine data from all detectors */
snprintf(s, 19999, "%d_%d_%s", i/args_info.nchunks_refinement_arg, (i+k)/args_info.nchunks_refinement_arg, veto_info[m].name);
}
ei[nei]=allocate_extreme_info(s);
ei[nei]->first_chunk=i;
ei[nei]->last_chunk=i+k;
ei[nei]->veto_num=m;
nei++;
}
}
*out_nei=nei;
*out_ei=ei;
}
/*
* Find the first occurrence of a file in the canonical search list:
* the current directory
* the home directory
* vile's subdirectory of the home directory
* the vile library-directory
*
* On Unix we look for file/directory names with a "." prefixed since that
* hides them.
*/
static FILE *
OpenKeywords(const char *table_name)
{
#define OPEN_IT(p) if ((fp = fopen(p, "r")) != 0) { \
VERBOSE(1,("Opened %s", p)); return fp; } else { \
VERBOSE(2,("..skip %s", p)); }
#define FIND_IT(p) sprintf p; OPEN_IT(str_keyword_name)
static char suffix[] = KEYFILE_SUFFIX;
FILE *fp;
const char *path;
size_t need;
char myLeaf[20];
need = sizeof(suffix) + strlen(table_name) + 2;
str_keyword_file = do_alloc(str_keyword_file, need, &len_keyword_file);
if (str_keyword_file == 0) {
CannotAllocate("OpenKeywords");
return 0;
}
sprintf(str_keyword_file, "%s%s", table_name, suffix);
if (strchr(str_keyword_file, PATHSEP) != 0) {
OPEN_IT(str_keyword_file);
}
if ((path = home_dir()) == 0)
path = "";
need = strlen(path)
+ strlen(str_keyword_file)
+ 20;
str_keyword_name = do_alloc(str_keyword_name, need, &len_keyword_name);
if (str_keyword_name == 0) {
CannotAllocate("OpenKeywords");
return 0;
}
FIND_IT((str_keyword_name, "%s%c%s%s", PATHDOT, PATHSEP, DOT_TO_HIDE_IT, str_keyword_file));
FIND_IT((str_keyword_name, "%s%c%s%s", path, PATHSEP, DOT_TO_HIDE_IT, str_keyword_file));
sprintf(myLeaf, "%s%s%c", DOT_TO_HIDE_IT, MY_NAME, PATHSEP);
FIND_IT((str_keyword_name, "%s%c%s%s", path, PATHSEP, myLeaf, str_keyword_file));
path = vile_getenv("VILE_STARTUP_PATH");
#ifdef VILE_STARTUP_PATH
if (path == 0)
path = VILE_STARTUP_PATH;
#endif
if (path != 0) {
int n = 0, m;
need = strlen(path) + strlen(str_keyword_file) + 2;
str_keyword_name = do_alloc(str_keyword_name, need, &len_keyword_name);
if (str_keyword_name == 0) {
CannotAllocate("OpenKeywords");
return 0;
}
while (path[n] != 0) {
for (m = n; path[m] != 0 && path[m] != PATHCHR; m++)
/*LOOP */ ;
FIND_IT((str_keyword_name, "%.*s%c%s", m - n, path + n, PATHSEP, str_keyword_file));
if (path[m])
n = m + 1;
else
n = m;
}
}
return 0;
}
static void* do_alloc(size_t i)
{
node_t* pn = heap->index[i];
node_t* prev = NULL;
while (pn)
{
if (pn->stat == MEM_STAT_FREE)
{
if (prev)
{
void* ret = pn->addr;
node_t* newNode = get_free_node();
prev->next = newNode;
newNode->addr = ret;
newNode->stat = MEM_STAT_USED;
newNode->len = indsiz[i];
newNode->next = pn;
pn->addr = (void*)((size_t)pn->addr + indsiz[i]);
pn->len -= indsiz[i];
if (pn->len == 0)
{
newNode->next = pn->next;
pn->next = heap->free_node;
heap->free_node = pn;
merge(prev);
}
return ret;
}
else
{
node_t* tmp = get_free_node();
tmp->addr = pn->addr;
tmp->len = indsiz[i];
tmp->next = pn;
tmp->stat = MEM_STAT_USED;
pn->addr = (void*)((size_t)pn->addr + indsiz[i]);
pn->len -= indsiz[i];
heap->index[i] = tmp;
if (pn->len == 0)
{
tmp->next = pn->next;
pn->next = heap->free_node;
heap->free_node = pn;
merge(tmp);
}
return tmp->addr;
}
}
else if (pn->next)
{
prev = pn;
pn = pn->next;
}
else
{
expand_heap(i);
return do_alloc(i);
}
}
expand_heap(i);
return do_alloc(i);
}
void add_frame_file(char *filename, double TStart, double TEnd)
{
char *p;
FrFile *ff;
FrVect *vect;
frame_file *fdata;
/* check that sample storage has been allocated */
if(data==NULL){
fprintf(stderr, "** You must use DURATION and SAMPLES_PER_SECOND commands before FRAME_FILES\n");
exit(-1);
}
/* remove leading whitespace */
while((*filename==' ')||(*filename=='\t'))filename++;
/* break at first newline */
for(p=filename;*p;p++)if(*p=='\n'){*p=0; break; }
/* remove trailing whitespace */
while((*p==' ')||(*p=='\t')){
*p=0;
if(p==filename)break;
p--;
}
fprintf(stderr,"Adding frame file \"%s\"\n", filename);
if(files_free>=files_size){
files_size=2*files_size+10;
/* reuse p.. we do not care it is the wrong type, void * is sufficient */
p=(char *)do_alloc(files_size, sizeof(frame_file));
if(files_free>0)memcpy(p, files, files_free*sizeof(frame_file));
if(files!=NULL)free(files);
files=(frame_file *)p;
}
fdata=&(files[files_free]);
fdata->name=strdup(filename);
fault_file(filename);
ff=FrFileINew(filename);
if(ff==NULL){
fprintf(stderr,"** Error opening \"%s\" for reading frame fdata\n", filename);
return;
}
if(TStart<0)TStart=FrFileITStart(ff);
if(TEnd<0)TEnd=FrFileITEnd(ff);
fprintf(stderr,"Opened frame file \"%s\" start=%f end=%f\n", filename, TStart, TEnd);
if((TStart > TEnd) || (TStart < 0)){
fprintf(stderr, "** TStart > TEnd || TStart < 0 on file %s\n", filename);
FrFileIEnd(ff);
return;
}
/* This does not appear to work - vect returns bogus values for start time.
if(TStart < gps_start)TStart=gps_start;
if(TEnd > gps_end)TEnd=gps_end;
*/
/* ok, file is opened and we _are_ able to read from it..
validate the entry and read the fdata */
files_free++;
fdata->gps_start=llrint(TStart);
fdata->gps_end=llrint(TEnd);
errno=0;
vect=FrFileIGetV(ff, channel, TStart, TEnd-TStart);
if((vect==NULL)||(errno!=0)){
fprintf(stderr,"** Could not find data for channel \"%s\" [%.10lg,%.10lg] in file \"%s\" (errno=%s)\n", channel, TStart, TEnd, filename, strerror(errno));
} else {
/* print_vect_trends(vect, 0, 16384); */
assimilate_data(vect);
FrVectFree(vect);
}
FrFileIEnd(ff);
}
inline MemRef Allocator::alloc(size_t size)
{
return do_alloc(size);
}
int main(int argc, char *argv[])
{
long i;
double window_sum;
LALStatus status={level:0, statusPtr: NULL};
PassBandParamStruc filterpar;
REAL4TimeSeries chan; /* must zero the f0 field */
fprintf(stderr,"make_sft_op version %s\n", MAKE_SFT_VERSION);
fprintf(stderr,"Using frame library %s\n", FrLibVersionF());
fprintf(stderr,"Using LAL version %s\n", LAL_VERSION);
yylex();
if(freq_start<0)freq_start=0;
if(freq_stop<0)freq_stop=total_samples;
/* post_init various subsystems */
post_init_response_files();
post_init_alpha_beta();
/* print settings */
print_settings(stderr);
/* start processing data */
print_data_stats();
print_data(file_debug1, "debug 1");
verify_loaded_data();
generate_fake_data();
linear_interpolate_gaps();
print_data(file_debug2, "debug 2");
/* this is a hack, but it significantly reduces memory footprint */
td_data=do_alloc(1,sizeof(*td_data));
td_data->length=total_samples;
td_data->data=data;
/* setup structure to hold input for Butterworth filter */
chan.data=NULL;
strncpy(chan.name,channel,LALNameLength);
chan.f0=0;
chan.name[LALNameLength-1]=0; /* make sure it is null-terminated */
chan.deltaT=1.0/samples_per_second;
chan.epoch.gpsSeconds=gps_start; /* no need */
chan.epoch.gpsNanoSeconds=0;
if(trace_power){
fprintf(stderr, "Input data total power=%.*g\n",
precision, sum_r4_squares(data, total_samples)/samples_per_second);
}
if(!bypass_highpass_filter && (highpass_filter_f>0) && (highpass_filter_a>0)){
fprintf(stderr,"Applying high pass filter, f=%g a=%g order=%d\n",
highpass_filter_f, highpass_filter_a, highpass_filter_order);
/* Setup Butterworth filter */
filterpar.name="Butterworth High Pass";
filterpar.nMax=highpass_filter_order;
filterpar.f2=highpass_filter_f;
filterpar.a2=highpass_filter_a;
/* values that are 'not given' = out of range */
filterpar.f1=-1.0;
filterpar.a1=-1.0;
/* REAL4Sequence is the same as REAL4Vector - according to lal/Datatypes.h */
chan.data=(REAL4Sequence *)td_data;
LALDButterworthREAL4TimeSeries(&status, &chan, &filterpar);
TESTSTATUS(&status);
if(trace_power){
fprintf(stderr, "After highpass filter total power=%.*g\n",
precision, sum_r4_squares(data, total_samples)/samples_per_second);
}
}
if(!bypass_lowpass_filter && (lowpass_filter_f>0) && (lowpass_filter_a > 0)){
fprintf(stderr,"Applying low pass filter, f=%g a=%g order=%d\n",
lowpass_filter_f, lowpass_filter_a, lowpass_filter_order);
/* Setup Butterworth filter */
filterpar.name="Butterworth Low Pass";
filterpar.nMax=lowpass_filter_order;
filterpar.f1=lowpass_filter_f;
filterpar.a1=lowpass_filter_a;
/* values that are 'not given' = out of range */
/* why 2*nsamples ? LAL used to have a bug in it where
the pairs were sorted before deciding whether the filter
is lowpass or highpass. Therefore, we need to specify a
large, out of range, frequency f so that we get a low-pass filter.
The maximum frequency is Nyquist, hence 2*nsamples is definitely out of range */
filterpar.f2=2*total_samples;
filterpar.a2=-1.0;
/* REAL4Sequence is the same as REAL4Vector - according to lal/Datatypes.h */
chan.data=(REAL4Sequence *)td_data;
LALDButterworthREAL4TimeSeries(&status, &chan, &filterpar);
TESTSTATUS(&status);
if(trace_power){
fprintf(stderr, "After lowpass filter total power=%.*g\n",
precision, sum_r4_squares(data, total_samples)/samples_per_second);
}
}
if(!bypass_first_window){
fprintf(stderr,"Applying Hann window to input data\n");
for(i=0;i<total_samples;i++)data[i]*=0.5*(1.0-cos((2.0*M_PI*i)/total_samples));
window_sum=0.5;
} else {
window_sum=1.0;
}
if(trace_power){
fprintf(stderr, "After windowing total power=%.*g\n",
precision, sum_r4_squares(data, total_samples)/samples_per_second);
}
for(i=0;i<3;i++){
fprintf(stderr,"Allocating phi[%ld]\n", i);
LALCCreateVector(&status, &(phi[i]), freq_stop-freq_start);
TESTSTATUS(&status);
}
compute_test_fft(td_data, phi, 3, freq_start, freq_stop);
/* now free td_data to conserve space */
free(td_data->data);
data=NULL;
free(td_data);
td_data=NULL;
LALCCreateVector(&status, &pgram, freq_stop-freq_start);
TESTSTATUS(&status);
compute_calibrated_periodogram3(phi, freq_start, freq_stop, pgram, window_sum);
print_COMPLEX8Vector(pgram, output_sft, "CALIBRATED FREQUENCY DOMAIN DATA", output_mode, 0, freq_stop-freq_start);
if(output_power!=NULL){
/* we need more space */
for(i=0;i<3;i++){
LALCDestroyVector(&status, &(phi[i]));
TESTSTATUS(&status);
}
LALSCreateVector(&status, &power, freq_stop-freq_start);
TESTSTATUS(&status);
for(i=0;i<freq_stop-freq_start;i++)
power->data[i]=(pgram->data[i].re*pgram->data[i].re+pgram->data[i].im*pgram->data[i].im);
print_REAL4Vector(power, output_power, "CALIBRATED POWER", output_mode, 0, freq_stop-freq_start);
}
/* we do not destroy large vectors when we are done unless we need
to allocate a lot of space again. This reduces run time
of the program */
return 0;
}
SUMMING_CONTEXT *create_summing_context(void)
{
SUMMING_CONTEXT *ctx;
ctx=do_alloc(1, sizeof(*ctx));
memset(ctx, 0, sizeof(*ctx));
fprintf(stderr, "Averaging mode: %s\n", args_info.averaging_mode_arg);
fprintf(stderr, "SSE: %d\n", args_info.sse_arg);
fprintf(LOG, "Averaging mode: %s\n", args_info.averaging_mode_arg);
fprintf(LOG, "SSE: %d\n", args_info.sse_arg);
ctx->diff_shift_granularity=0;
#define MODE(a) (args_info.sse_arg ? (sse_ ## a) : (a) )
/* default values appropriate for particular averaging mode */
if(!strcasecmp(args_info.averaging_mode_arg, "matched")) {
ctx->get_uncached_power_sum=MODE(get_uncached_matched_power_sum);
ctx->accumulate_power_sum_cached=accumulate_power_sum_cached1;
ctx->accumulate_power_sums=accumulate_power_sums_sidereal_step;
ctx->cache_granularity=8;
ctx->sidereal_group_count=24;
ctx->summing_step=864000; /* ten days */
} else
if(!strcasecmp(args_info.averaging_mode_arg, "single_bin_loose")) {
fprintf(LOG, "single_bin_loose: only tested with delta of pi/2 and pi/5\n");
fprintf(stderr, "single_bin_loose: only tested with delta of pi/2 and pi/5\n");
ctx->get_uncached_power_sum=MODE(get_uncached_loose_single_bin_partial_power_sum);
ctx->accumulate_power_sum_cached=accumulate_power_sum_cached_diff;
ctx->accumulate_power_sums=accumulate_single_bin_loose_power_sums_sidereal_step;
ctx->cache_granularity=8; /* TODO: find actual value from experiment */
ctx->diff_shift_granularity=8192*8;
ctx->sidereal_group_count=12;
ctx->summing_step=86400*3; /* three days */
ctx->time_group_count=3;
ctx->cross_terms_present=args_info.compute_cross_terms_arg;
} else
if(!strcasecmp(args_info.averaging_mode_arg, "matched_loose")) {
fprintf(LOG, "**** WARNING matched_loose: this experimental code has not been reviewed yet.\n");
fprintf(stderr, "**** WARNING matched_loose: this experimental code has not been reviewed yet.\n");
ctx->get_uncached_power_sum=get_uncached_loose_matched_partial_power_sum;
ctx->accumulate_power_sum_cached=accumulate_power_sum_cached_diff;
ctx->accumulate_power_sums=accumulate_matched_loose_power_sums_sidereal_step;
ctx->cache_granularity=8; /* TODO: find actual value from experiment */
ctx->diff_shift_granularity=8192*8;
ctx->sidereal_group_count=12;
ctx->summing_step=86400*3; /* three days */
ctx->time_group_count=3;
ctx->cross_terms_present=args_info.compute_cross_terms_arg;
} else
if(!strcasecmp(args_info.averaging_mode_arg, "3") || !strcasecmp(args_info.averaging_mode_arg, "three")) {
fprintf(stderr, "PowerFlux2 does not support 3-bin mode\n");
exit(-1);
} else
if(!strcasecmp(args_info.averaging_mode_arg, "1") || !strcasecmp(args_info.averaging_mode_arg, "one")) {
ctx->get_uncached_power_sum=MODE(get_uncached_single_bin_power_sum);
ctx->accumulate_power_sum_cached=accumulate_power_sum_cached1;
ctx->accumulate_power_sums=accumulate_power_sums_sidereal_step;
ctx->cache_granularity=1;
ctx->sidereal_group_count=24;
ctx->summing_step=864000; /* ten days */
} else {
fprintf(stderr, "Unrecognized averaging mode: %s\n", args_info.averaging_mode_arg);
exit(-1);
}
/* apply command line overrides */
if(args_info.cache_granularity_given) {
ctx->cache_granularity=args_info.cache_granularity_arg;
if(ctx->cache_granularity<1) {
fprintf(stderr, "*** ERROR: cache granularity must be positive\n");
fprintf(LOG, "*** ERROR: cache granularity must be positive\n");
exit(-1);
}
}
if(args_info.summing_step_given) {
ctx->summing_step=args_info.summing_step_arg;
}
if(args_info.sidereal_group_count_given) {
ctx->sidereal_group_count=args_info.sidereal_group_count_arg;
if(ctx->sidereal_group_count<1) {
fprintf(stderr, "*** ERROR: sidereal_group_count must be positive\n");
fprintf(LOG, "*** ERROR: sidereal_group_count must be positive\n");
exit(-1);
}
}
if(args_info.time_group_count_given) {
ctx->time_group_count=args_info.time_group_count_arg;
if(ctx->time_group_count<1) {
fprintf(stderr, "*** ERROR: time_group_count must be positive\n");
fprintf(LOG, "*** ERROR: time_group_count must be positive\n");
exit(-1);
}
}
ctx->inv_cache_granularity=1.0/ctx->cache_granularity;
ctx->half_inv_cache_granularity=0.5/ctx->cache_granularity;
ctx->inv_diff_shift_granularity=1.0/ctx->diff_shift_granularity;
ctx->half_inv_diff_shift_granularity=0.5/ctx->diff_shift_granularity;
fprintf(LOG, "summing_step: %g\n", ctx->summing_step);
fprintf(LOG, "cache_granularity: %d\n", ctx->cache_granularity);
fprintf(LOG, "diff_shift_granularity: %d\n", ctx->diff_shift_granularity);
fprintf(LOG, "sidereal_group_count: %d\n", ctx->sidereal_group_count);
fprintf(LOG, "time_group_count: %d\n", ctx->time_group_count);
fprintf(LOG, "phase_mismatch: %g\n", args_info.phase_mismatch_arg);
fprintf(LOG, "cross_terms_present: %d\n", ctx->cross_terms_present);
allocate_simple_cache(ctx);
ctx->loose_first_half_count=-1;
return(ctx);
}
EXTREME_INFO * allocate_extreme_info(char *name)
{
EXTREME_INFO *ei;
int i;
ei=do_alloc(1, sizeof(*ei));
memset(ei, 0, sizeof(*ei));
ei->name=strdup(name);
thread_mutex_init(&(ei->mutex));
if(args_info.compute_skymaps_arg) {
ei->ul_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->ul_freq_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->circ_ul_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->circ_ul_freq_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->snr_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->snr_ul_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->snr_freq_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->max_weight_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->min_weight_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->weight_loss_fraction_skymap=do_alloc(patch_grid->npoints, sizeof(float));
ei->ks_skymap=do_alloc(patch_grid->npoints, sizeof(float));
}
ei->band_info=do_alloc(fine_grid->nbands, sizeof(*ei->band_info));
memset(ei->band_info, 0, fine_grid->nbands*sizeof(*ei->band_info));
ei->band_valid_count=do_alloc(fine_grid->nbands, sizeof(*ei->band_valid_count));
ei->band_masked_count=do_alloc(fine_grid->nbands, sizeof(*ei->band_masked_count));
memset(ei->band_valid_count, 0, fine_grid->nbands*sizeof(*ei->band_valid_count));
memset(ei->band_masked_count, 0, fine_grid->nbands*sizeof(*ei->band_masked_count));
for(i=0;i<fine_grid->nbands;i++) {
ei->band_info[i].max_weight=-1;
}
return ei;
}
