int event_loop_run() {
int timeout = global_event_loop.min_timer_value;
while (1) {
int ret = poll(global_event_loop.fds, global_event_loop.fd_entries.size, timeout);
if (ret == -1) {
msg(MSG_ERROR, "Error occured while polling: %s", strerror(errno));
continue;
}
if (ret > 0) {
// At least one file descriptor is ready for reading
size_t i;
for (i = 0; i < global_event_loop.fd_entries.size; i++) {
struct event_loop_fd_entry *fd_entry =
((struct event_loop_fd_entry *) global_event_loop.fd_entries.buffer) + i;
struct pollfd *fd = global_event_loop.fds + i;
// DPRINTF("%d", fd->revents);
if (fd->revents & POLLIN)
(*fd_entry->callback)(fd_entry->fd, fd_entry->user_param);
else if (fd->revents & (POLLERR | POLLHUP | POLLNVAL)) {
if (fd_entry->error_callback)
(*fd_entry->error_callback)(fd_entry->fd, fd_entry->user_param);
// Remove from event loop
array_remove_item(&global_event_loop.fd_entries, i);
// Remove from pollfd list
memmove(global_event_loop.fds + i,
global_event_loop.fds + i + 1,
global_event_loop.fd_entries.size - i);
global_event_loop.fds =
(struct pollfd *) realloc(global_event_loop.fds,
sizeof(struct pollfd) * (global_event_loop.fd_entries.size));
i--;
}
}
}
size_t i;
struct timeval now;
int diff;
timeout = global_event_loop.min_timer_value;
gettimeofday(&now, NULL);
for (i = 0; i < global_event_loop.timer_entries.size; i++) {
struct event_loop_timer_entry *timer_entry = ((struct event_loop_timer_entry *) global_event_loop.timer_entries.buffer) + i;
if (timer_entry->next_run.tv_sec < now.tv_sec || (timer_entry->next_run.tv_sec == now.tv_sec && timer_entry->next_run.tv_usec <= now.tv_usec)) {
DPRINTF("Running timer due to expiry");
(*timer_entry->callback)(timer_entry->user_param);
add_time(&now, &timer_entry->next_run, timer_entry->ms_timeout);
}
diff = (timer_entry->next_run.tv_sec - now.tv_sec) * 1000 + (timer_entry->next_run.tv_usec - now.tv_usec) / 1000;
if (diff < timeout && diff != 0)
timeout = diff;
}
}
return 0;
}
int DispatcherPrivate::wall_add(int timespan)
{
return add_time(_wall.read_us(), timespan);
}
static void up_click_handler(ClickRecognizerRef recognizer, void *context) {
if (remaining < 99 * 60 * 1000) {
add_time(1000 * 60);
}
display_time();
}
int main(int argc, char **argv) {
int ret;
int provided;
int i;
struct mdhim_t *md;
int total = 0;
struct mdhim_brm_t *brm, *brmp;
struct mdhim_bgetrm_t *bgrm, *bgrmp;
struct timeval start_tv, end_tv;
char *db_path = "./";
char *db_name = "mdhimTstDB-";
int dbug = MLOG_DBG; //MLOG_CRIT=1, MLOG_DBG=2
mdhim_options_t *db_opts; // Local variable for db create options to be passed
int db_type = LEVELDB; //(data_store.h)
long double put_time = 0;
long double get_time = 0;
struct index_t *secondary_local_index;
struct secondary_bulk_info *secondary_info;
int num_keys[KEYS];
MPI_Comm comm;
// Create options for DB initialization
db_opts = mdhim_options_init();
mdhim_options_set_db_path(db_opts, db_path);
mdhim_options_set_db_name(db_opts, db_name);
mdhim_options_set_db_type(db_opts, db_type);
mdhim_options_set_key_type(db_opts, MDHIM_LONG_INT_KEY);
mdhim_options_set_max_recs_per_slice(db_opts, SLICE_SIZE);
mdhim_options_set_server_factor(db_opts, 4);
mdhim_options_set_debug_level(db_opts, dbug);
//Initialize MPI with multiple thread support
ret = MPI_Init_thread(&argc, &argv, MPI_THREAD_MULTIPLE, &provided);
if (ret != MPI_SUCCESS) {
printf("Error initializing MPI with threads\n");
exit(1);
}
//Quit if MPI didn't initialize with multiple threads
if (provided != MPI_THREAD_MULTIPLE) {
printf("Not able to enable MPI_THREAD_MULTIPLE mode\n");
exit(1);
}
gettimeofday(&start_tv, NULL);
//Initialize MDHIM
comm = MPI_COMM_WORLD;
md = mdhimInit(&comm, db_opts);
if (!md) {
printf("Error initializing MDHIM\n");
MPI_Abort(MPI_COMM_WORLD, ret);
exit(1);
}
key_lens = malloc(sizeof(int) * KEYS);
value_lens = malloc(sizeof(int) * KEYS);
keys = malloc(sizeof(uint64_t *) * KEYS);
values = malloc(sizeof(uint64_t *) * KEYS);
secondary_key_lens = malloc(sizeof(int *) * KEYS);
secondary_keys = malloc(sizeof(uint64_t **) * KEYS);
memset(secondary_keys, 0, sizeof(uint64_t **) * KEYS);
/* Primary and secondary key entries */
MPI_Barrier(MPI_COMM_WORLD);
total = 0;
secondary_local_index = create_local_index(md, LEVELDB,
MDHIM_LONG_INT_KEY, NULL);
for (i = 0; i < KEYS; i++) {
num_keys[i] = 1;
}
while (total != TOTAL_KEYS) {
//Populate the primary keys and values to insert
gen_keys_values(md->mdhim_rank, total);
secondary_info = mdhimCreateSecondaryBulkInfo(secondary_local_index,
(void ***) secondary_keys,
secondary_key_lens, num_keys,
SECONDARY_LOCAL_INFO);
//record the start time
start_record(&start_tv);
//Insert the primary keys into MDHIM
brm = mdhimBPut(md, (void **) keys, key_lens,
(void **) values, value_lens, KEYS,
NULL, secondary_info);
//Record the end time
end_record(&end_tv);
//Add the final time
add_time(&start_tv, &end_tv, &put_time);
if (!brm || brm->error) {
printf("Rank - %d: Error inserting keys/values into MDHIM\n", md->mdhim_rank);
}
while (brm) {
if (brm->error < 0) {
printf("Rank: %d - Error inserting key/values info MDHIM\n", md->mdhim_rank);
}
brmp = brm->next;
//Free the message
mdhim_full_release_msg(brm);
brm = brmp;
}
free_key_values();
mdhimReleaseSecondaryBulkInfo(secondary_info);
total += KEYS;
}
/* End primary and secondary entries */
MPI_Barrier(MPI_COMM_WORLD);
/* End secondary key entries */
//Commit the database
ret = mdhimCommit(md, md->primary_index);
if (ret != MDHIM_SUCCESS) {
printf("Error committing MDHIM database\n");
} else {
printf("Committed MDHIM database\n");
}
//Get the stats for the secondary index so the client figures out who to query
ret = mdhimStatFlush(md, secondary_local_index);
if (ret != MDHIM_SUCCESS) {
printf("Error getting stats\n");
} else {
printf("Got stats\n");
}
MPI_Barrier(MPI_COMM_WORLD);
//Retrieve the primary key's values from the secondary key
total = 0;
while (total != TOTAL_KEYS) {
//Populate the keys and values to retrieve
gen_keys_values(md->mdhim_rank, total);
start_record(&start_tv);
//Get the values back for each key inserted
for (i = 0; i < KEYS; i++) {
bgrm = mdhimBGet(md, secondary_local_index,
(void **) secondary_keys[i], secondary_key_lens[i],
1, MDHIM_GET_PRIMARY_EQ);
}
end_record(&end_tv);
add_time(&start_tv, &end_tv, &get_time);
while (bgrm) {
/* if (!bgrm || bgrm->error) {
printf("Rank: %d - Error retrieving values starting at: %llu",
md->mdhim_rank, (long long unsigned int) *keys[0]);
} */
//Validate that the data retrieved is the correct data
for (i = 0; i < bgrm->num_keys && !bgrm->error; i++) {
if (!bgrm->value_lens[i]) {
printf("Rank: %d - Got an empty value for key: %llu",
md->mdhim_rank, *(long long unsigned int *)bgrm->keys[i]);
continue;
}
}
bgrmp = bgrm;
bgrm = bgrm->next;
mdhim_full_release_msg(bgrmp);
}
free_key_values();
total += KEYS;
}
free(key_lens);
free(keys);
free(values);
free(value_lens);
free(secondary_key_lens);
free(secondary_keys);
MPI_Barrier(MPI_COMM_WORLD);
//Quit MDHIM
ret = mdhimClose(md);
gettimeofday(&end_tv, NULL);
if (ret != MDHIM_SUCCESS) {
printf("Error closing MDHIM\n");
}
MPI_Barrier(MPI_COMM_WORLD);
MPI_Finalize();
printf("Took: %Lf seconds to put %d keys\n",
put_time, TOTAL_KEYS * 2);
printf("Took: %Lf seconds to get %d keys/values\n",
get_time, TOTAL_KEYS * 2);
return 0;
}
static int
parse_rock_ridge_stat_internal(iso9660_dir_t *p_iso9660_dir,
iso9660_stat_t *p_stat, int regard_xa)
{
int len;
unsigned char * chr;
int symlink_len = 0;
CONTINUE_DECLS;
if (nope == p_stat->rr.b3_rock) return 0;
SETUP_ROCK_RIDGE(p_iso9660_dir, chr, len);
if (regard_xa)
{
chr+=14;
len-=14;
if (len<0) len=0;
}
/* repeat:*/
{
int sig;
iso_extension_record_t * rr;
int rootflag;
while (len > 1){ /* There may be one byte for padding somewhere */
rr = (iso_extension_record_t *) chr;
if (rr->len == 0) goto out; /* Something got screwed up here */
sig = from_721(*chr);
chr += rr->len;
len -= rr->len;
switch(sig){
case SIG('S','P'):
CHECK_SP(goto out);
break;
case SIG('C','E'):
CHECK_CE;
break;
case SIG('E','R'):
p_stat->rr.b3_rock = yep;
cdio_debug("ISO 9660 Extensions: ");
{ int p;
for(p=0;p<rr->u.ER.len_id;p++) cdio_debug("%c",rr->u.ER.data[p]);
}
break;
case SIG('P','X'):
p_stat->rr.st_mode = from_733(rr->u.PX.st_mode);
p_stat->rr.st_nlinks = from_733(rr->u.PX.st_nlinks);
p_stat->rr.st_uid = from_733(rr->u.PX.st_uid);
p_stat->rr.st_gid = from_733(rr->u.PX.st_gid);
break;
case SIG('P','N'):
/* Device major,minor number */
{ int32_t high, low;
high = from_733(rr->u.PN.dev_high);
low = from_733(rr->u.PN.dev_low);
/*
* The Rock Ridge standard specifies that if sizeof(dev_t) <= 4,
* then the high field is unused, and the device number is completely
* stored in the low field. Some writers may ignore this subtlety,
* and as a result we test to see if the entire device number is
* stored in the low field, and use that.
*/
if((low & ~0xff) && high == 0) {
p_stat->rr.i_rdev = CDIO_MKDEV(low >> 8, low & 0xff);
} else {
p_stat->rr.i_rdev = CDIO_MKDEV(high, low);
}
}
break;
case SIG('T','F'):
/* Time stamp(s) for a file */
{
int cnt = 0;
add_time(ISO_ROCK_TF_CREATE, create);
add_time(ISO_ROCK_TF_MODIFY, modify);
add_time(ISO_ROCK_TF_ACCESS, access);
add_time(ISO_ROCK_TF_ATTRIBUTES, attributes);
add_time(ISO_ROCK_TF_BACKUP, backup);
add_time(ISO_ROCK_TF_EXPIRATION, expiration);
add_time(ISO_ROCK_TF_EFFECTIVE, effective);
p_stat->rr.b3_rock = yep;
break;
}
case SIG('S','L'):
{
/* Symbolic link */
uint8_t slen;
iso_rock_sl_part_t * p_sl;
iso_rock_sl_part_t * p_oldsl;
slen = rr->len - 5;
p_sl = &rr->u.SL.link;
p_stat->rr.i_symlink = symlink_len;
while (slen > 1){
rootflag = 0;
switch(p_sl->flags &~1){
case 0:
realloc_symlink(p_stat, p_sl->len);
memcpy(&(p_stat->rr.psz_symlink[p_stat->rr.i_symlink]),
p_sl->text, p_sl->len);
p_stat->rr.i_symlink += p_sl->len;
break;
case 4:
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '.';
/* continue into next case. */
case 2:
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '.';
break;
case 8:
rootflag = 1;
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '/';
p_stat->rr.i_symlink++;
break;
default:
cdio_warn("Symlink component flag not implemented");
}
slen -= p_sl->len + 2;
p_oldsl = p_sl;
p_sl = (iso_rock_sl_part_t *) (((char *) p_sl) + p_sl->len + 2);
if (slen < 2) {
if (((rr->u.SL.flags & 1) != 0) && ((p_oldsl->flags & 1) == 0))
p_stat->rr.i_symlink += 1;
break;
}
/*
* If this component record isn't continued, then append a '/'.
*/
if (!rootflag && (p_oldsl->flags & 1) == 0) {
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '/';
}
}
}
symlink_len = p_stat->rr.i_symlink;
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[symlink_len]='\0';
break;
case SIG('R','E'):
cdio_warn("Attempt to read p_stat for relocated directory");
goto out;
#if FINISHED
case SIG('C','L'):
{
iso9660_stat_t * reloc;
ISOFS_I(p_stat)->i_first_extent = from_733(rr->u.CL.location);
reloc = isofs_iget(p_stat->rr.i_sb, p_stat->rr.i_first_extent, 0);
if (!reloc)
goto out;
p_stat->rr.st_mode = reloc->st_mode;
p_stat->rr.st_nlinks = reloc->st_nlinks;
p_stat->rr.st_uid = reloc->st_uid;
p_stat->rr.st_gid = reloc->st_gid;
p_stat->rr.i_rdev = reloc->i_rdev;
p_stat->rr.i_symlink = reloc->i_symlink;
p_stat->rr.i_blocks = reloc->i_blocks;
p_stat->rr.i_atime = reloc->i_atime;
p_stat->rr.i_ctime = reloc->i_ctime;
p_stat->rr.i_mtime = reloc->i_mtime;
iput(reloc);
}
break;
#endif
default:
break;
}
}
/*!
Get
@return length of name field; 0: not found, -1: to be ignored
*/
int
get_rock_ridge_filename(iso9660_dir_t * p_iso9660_dir,
/*out*/ char * psz_name,
/*in/out*/ iso9660_stat_t *p_stat)
{
int len;
unsigned char *chr;
int symlink_len = 0;
CONTINUE_DECLS;
int i_namelen = 0;
int truncate=0;
if (!p_stat || nope == p_stat->rr.b3_rock) return 0;
*psz_name = 0;
SETUP_ROCK_RIDGE(p_iso9660_dir, chr, len);
/*repeat:*/
{
iso_extension_record_t * rr;
int sig;
int rootflag;
while (len > 1){ /* There may be one byte for padding somewhere */
rr = (iso_extension_record_t *) chr;
if (rr->len == 0) goto out; /* Something got screwed up here */
sig = *chr+(*(chr+1) << 8);
chr += rr->len;
len -= rr->len;
switch(sig){
case SIG('S','P'):
CHECK_SP(goto out);
break;
case SIG('C','E'):
{
iso711_t i_fname = from_711(p_iso9660_dir->filename_len);
if ('\0' == p_iso9660_dir->filename[0] && 1 == i_fname)
break;
if ('\1' == p_iso9660_dir->filename[0] && 1 == i_fname)
break;
}
CHECK_CE;
break;
case SIG('E','R'):
p_stat->rr.b3_rock = yep;
cdio_debug("ISO 9660 Extensions: ");
{
int p;
for(p=0;p<rr->u.ER.len_id;p++) cdio_debug("%c",rr->u.ER.data[p]);
}
break;
case SIG('N','M'):
/* Alternate name */
p_stat->rr.b3_rock = yep;
if (truncate) break;
if (rr->u.NM.flags & ISO_ROCK_NM_PARENT) {
i_namelen = sizeof("..");
strncat(psz_name, "..", i_namelen);
} else if (rr->u.NM.flags & ISO_ROCK_NM_CURRENT) {
i_namelen = sizeof(".");
strncat(psz_name, ".", i_namelen);
break;
}
if (rr->u.NM.flags & ~1) {
cdio_info("Unsupported NM flag settings (%d)",rr->u.NM.flags);
break;
}
if((strlen(psz_name) + rr->len - 5) >= 254) {
truncate = 1;
break;
}
strncat(psz_name, rr->u.NM.name, rr->len - 5);
i_namelen += rr->len - 5;
break;
case SIG('P','X'):
/* POSIX file attributes */
p_stat->rr.st_mode = from_733(rr->u.PX.st_mode);
p_stat->rr.st_nlinks = from_733(rr->u.PX.st_nlinks);
p_stat->rr.st_uid = from_733(rr->u.PX.st_uid);
p_stat->rr.st_gid = from_733(rr->u.PX.st_gid);
p_stat->rr.b3_rock = yep;
break;
case SIG('S','L'):
{
/* Symbolic link */
uint8_t slen;
iso_rock_sl_part_t * p_sl;
iso_rock_sl_part_t * p_oldsl;
slen = rr->len - 5;
p_sl = &rr->u.SL.link;
p_stat->rr.i_symlink = symlink_len;
while (slen > 1){
rootflag = 0;
switch(p_sl->flags &~1){
case 0:
realloc_symlink(p_stat, p_sl->len);
memcpy(&(p_stat->rr.psz_symlink[p_stat->rr.i_symlink]),
p_sl->text, p_sl->len);
p_stat->rr.i_symlink += p_sl->len;
break;
case 4:
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '.';
/* continue into next case. */
case 2:
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '.';
break;
case 8:
rootflag = 1;
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '/';
break;
default:
cdio_warn("Symlink component flag not implemented");
}
slen -= p_sl->len + 2;
p_oldsl = p_sl;
p_sl = (iso_rock_sl_part_t *) (((char *) p_sl) + p_sl->len + 2);
if (slen < 2) {
if (((rr->u.SL.flags & 1) != 0) && ((p_oldsl->flags & 1) == 0))
p_stat->rr.i_symlink += 1;
break;
}
/*
* If this component record isn't continued, then append a '/'.
*/
if (!rootflag && (p_oldsl->flags & 1) == 0) {
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[p_stat->rr.i_symlink++] = '/';
}
}
}
symlink_len = p_stat->rr.i_symlink;
realloc_symlink(p_stat, 1);
p_stat->rr.psz_symlink[symlink_len]='\0';
break;
case SIG('R','E'):
free(buffer);
return -1;
case SIG('T','F'):
/* Time stamp(s) for a file */
{
int cnt = 0;
add_time(ISO_ROCK_TF_CREATE, create);
add_time(ISO_ROCK_TF_MODIFY, modify);
add_time(ISO_ROCK_TF_ACCESS, access);
add_time(ISO_ROCK_TF_ATTRIBUTES, attributes);
add_time(ISO_ROCK_TF_BACKUP, backup);
add_time(ISO_ROCK_TF_EXPIRATION, expiration);
add_time(ISO_ROCK_TF_EFFECTIVE, effective);
p_stat->rr.b3_rock = yep;
break;
}
default:
break;
}
}
}
free(buffer);
return i_namelen; /* If 0, this file did not have a NM field */
out:
free(buffer);
return 0;
}
int f_fcst_ave(ARG2) {
struct ave_struct *save;
int i, pdt, new_type;
int year, month, day, hour, minute, second;
int tyear, tmonth, tday, thour, tminute, tsecond;
int missing;
char string[10];
// initialization
if (mode == -1) {
save_translation = decode = 1;
// allocate static structure
*local = save = (struct ave_struct *) malloc( sizeof(struct ave_struct));
if (save == NULL) fatal_error("memory allocation fcst_ave","");
i = sscanf(arg1, "%d%2s", &save->dt,string);
if (i != 2) fatal_error("fcst_ave: delta-time: (int)(2 characters) %s", arg1);
save->dt_unit = -1;
if (strcmp(string,"hr") == 0) save->dt_unit = 1;
else if (strcmp(string,"dy") == 0) save->dt_unit = 2;
else if (strcmp(string,"mo") == 0) save->dt_unit = 3;
else if (strcmp(string,"yr") == 0) save->dt_unit = 4;
if (save->dt_unit == -1) fatal_error("fcst_ave: unsupported time unit %s", string);
if ((save->output = ffopen(arg2, file_append ? "ab" : "wb")) == NULL) {
fatal_error("fcst_ave: could not open file %s", arg2);
}
save->has_val = 0;
save->n = NULL;
save->sum = NULL;
init_sec(save->first_sec);
init_sec(save->next_sec);
return 0;
}
save = (struct ave_struct *) *local;
if (mode == -2) { // cleanup
if (save->has_val == 1) {
do_ave(save);
}
ffclose(save->output);
free_ave_struct(save);
return 0;
}
// if data
if (mode >= 0) {
// 1/2015 use_scale = 0;
pdt = GB2_ProdDefTemplateNo(sec);
if (mode == 98) fprintf(stderr,"fcst_ave: pdt=%d\n",pdt);
// only support pdt == 0, 1 and 8
if (pdt != 0 && pdt != 1 && pdt != 8) return 0;
// first time through .. save data and return
if (save->has_val == 0) { // new data: write and save
init_ave_struct(save,ndata);
add_to_ave_struct(save, sec, data, ndata, 0);
// copy sec
copy_sec(sec, save->first_sec);
copy_sec(sec, save->next_sec);
// get reference time and save it
get_time(sec[1]+12,&save->ref_year, &save->ref_month, &save->ref_day, &save->ref_hour, &save->ref_minute, &save->ref_second);
if (start_ft(sec, &save->fcst_year, &save->fcst_month, &save->fcst_day, &save->fcst_hour,
&save->fcst_minute, &save->fcst_second) != 0) {
fatal_error("fcst_ave: could not determine the start FT time","");
}
// get verf time and save it
if (verftime(sec, &save->year2, &save->month2, &save->day2, &save->hour2, &save->minute2, &save->second2) != 0) {
fatal_error("fcst_ave: could not determine the verification time","");
}
save->has_val = 1;
return 0;
}
// check to see if new variable
new_type = 0;
// get the reference time of field
get_time(sec[1]+12, &year, &month, &day, &hour, &minute, &second);
// see if reference time has not changed
if (year != save->ref_year) new_type = 1;
else if (month != save->ref_month) new_type = 1;
else if (day != save->ref_day) new_type = 1;
else if (hour != save->ref_hour) new_type = 1;
else if (minute != save->ref_minute) new_type = 1;
else if (second != save->ref_second) new_type = 1;
if (new_type == 0) {
if (same_sec0(sec,save->first_sec) == 0 ||
same_sec1_not_time(sec,save->first_sec) == 0 ||
same_sec3(sec,save->first_sec) == 0 ||
same_sec4_not_time(sec,save->first_sec) == 0)
new_type = 1;
if (mode == 98) fprintf(stderr, "fcst_ave: testsec %d %d %d %d\n", same_sec0(sec,save->first_sec),
same_sec1_not_time(sec,save->first_sec),
same_sec3(sec,save->first_sec),
same_sec4_not_time(sec,save->first_sec));
}
if (mode == 98) fprintf(stderr, "fcst_ave: new_type %d\n", new_type);
// unlike f_ave, assume no missing .. it is a fcst not observations
// check to see if verification date is expected value
if (new_type == 0) {
tyear = save->fcst_year;
tmonth = save->fcst_month;
tday = save->fcst_day;
thour = save->fcst_hour;
tminute = save->fcst_minute;
tsecond = save->fcst_second;
add_time(&tyear, &tmonth, &tday, &thour, &tminute, &tsecond, save->dt, save->dt_unit);
if (start_ft(sec, &year, &month, &day, &hour, &minute, &second) != 0)
fatal_error("fcst_ave: could not determine the start_ft time","");
if (cmp_time(year,month,day,hour,minute,second,tyear,tmonth,tday,thour,tminute,tsecond)) {
new_type = 1;
if (mode == 98) fprintf(stderr, "fcst_ave: unexpected verf time, new_type=1\n");
}
else {
save->fcst_year = year;
save->fcst_month = month;
save->fcst_day = day;
save->fcst_hour = hour;
save->fcst_minute = minute;
save->fcst_second = second;
}
}
// check to see if verification date is expected value
missing = 0;
if (new_type == 0) {
if (verftime(sec, &year, &month, &day, &hour, &minute, &second) != 0)
fatal_error("fcst_ave: could not determine the verification time","");
tyear = save->year2;
tmonth = save->month2;
tday = save->day2;
thour = save->hour2;
tminute = save->minute2;
tsecond = save->second2;
add_time(&tyear, &tmonth, &tday, &thour, &tminute, &tsecond, save->dt, save->dt_unit);
if (cmp_time(year,month,day,hour,minute,second,tyear,tmonth,tday,thour,tminute,tsecond) != 0) new_type = 1;
else {
save->year2 = year;
save->month2 = month;
save->day2 = day;
save->hour2 = hour;
save->minute2 = minute;
save->second2 = second;
}
}
// if data is the same as the previous, update the sum
if (mode == 98) fprintf(stderr, "fcst_ave ave: before update_sum new_type %d\n", new_type);
if (new_type == 0) { // update sum
if (mode == 98) fprintf(stderr, "fcst_ave: update sum\n");
add_to_ave_struct(save, sec, data, ndata, missing);
return 0;
}
// new field, do grib output and save current data
do_ave(save);
init_ave_struct(save, ndata);
add_to_ave_struct(save, sec, data, ndata, 0);
copy_sec(sec, save->first_sec);
copy_sec(sec, save->next_sec);
// get reference time and save it
get_time(sec[1]+12,&save->ref_year, &save->ref_month, &save->ref_day, &save->ref_hour, &save->ref_minute, &save->ref_second);
if (start_ft(sec, &save->fcst_year, &save->fcst_month, &save->fcst_day, &save->fcst_hour,
&save->fcst_minute, &save->fcst_second) != 0) {
fatal_error("fcst_ave: could not determine the start FT time","");
}
// get verf time and save it
if (verftime(sec, &save->year2, &save->month2, &save->day2, &save->hour2, &save->minute2, &save->second2) != 0) {
fatal_error("fcst_ave: could not determine the verification time","");
}
save->has_val = 1;
return 0;
}
return 0;
}
/***************************************************************
* Ceos_init_stVec:
* Reads state vectors from given CEOS file, writing them in the
* appropriate format to SAR parameters structure.*/
void ceos_init_stVec(const char *fName, ceos_description *ceos,
meta_parameters *meta)
{
struct pos_data_rec ppdr;
/*Fetch platform position data record.*/
get_ppdr(fName,&ppdr);
// Read the state vectors from the leader data file, adjust coordinate system, etc.
// and write them to the SAR parameters structures
ceos_read_stVecs(fName, ceos, meta);
// For ALOS Palsar orbits only
// Don't propagate but select nine state vectors around the center for the
// higher order interpolation scheme
if (ceos->processor == ALOS_PROC) {
// Determine closest state vector
int ii, min;
double diff = 99999999;
for (ii=0; ii<meta->state_vectors->vector_count; ii++) {
if (fabs(meta->state_vectors->vecs[ii].time) < diff) {
diff = fabs(meta->state_vectors->vecs[ii].time);
min = ii;
}
}
// Populate a new state vector
ymd_date img_ymd;
julian_date img_jd;
hms_time img_time;
img_jd.year = meta->state_vectors->year;
img_jd.jd = meta->state_vectors->julDay;
date_sec2hms(meta->state_vectors->second,&img_time);
date_jd2ymd(&img_jd, &img_ymd);
add_time((min-4)*60, &img_ymd, &img_time);
date_ymd2jd(&img_ymd, &img_jd);
meta_state_vectors *new_st = meta_state_vectors_init(9);
new_st->year = img_jd.year;
new_st->julDay = img_jd.jd;
new_st->second = date_hms2sec(&img_time);
for (ii=0; ii<9; ii++)
new_st->vecs[ii] = meta->state_vectors->vecs[ii+min-4];
FREE(meta->state_vectors);
meta->state_vectors = new_st;
meta->sar->time_shift = 0.0;
}
// Propagate three state vectors for regular frames
else if (ceos->processor != PREC && ceos->processor != unknownProcessor) {
int vector_count=3;
double data_int = meta->sar->original_line_count / 2
* fabs(meta->sar->azimuth_time_per_pixel);
meta->state_vectors->vecs[0].time = get_timeDelta(ceos, &ppdr, meta);
if (ceos->processor != PREC && data_int < 360.0) {
while (fabs(data_int) > 15.0) {
data_int /= 2;
vector_count = vector_count*2-1;
}
// propagate three state vectors: start, center, end
propagate_state(meta, vector_count, data_int);
}
}
}
