bool task_list::load(const std::string& filename)
{
std::string load_json_string;
if(msl::file_to_string(filename,load_json_string))
{
msl::json load_json(load_json_string);
std::vector<task> temp_list;
for(unsigned int ii=0;ii<(unsigned int)msl::to_int(load_json.get("size"));++ii)
{
msl::json task_json=load_json.get(msl::to_string(ii));
date temp_date(msl::to_int(task_json.get("due_day")),msl::to_int(task_json.get("due_month")),msl::to_int(task_json.get("due_year")));
task temp_task;
temp_task.due_date=temp_date;
temp_task.info=task_json.get("info");
temp_task.name=task_json.get("name");
temp_task.time_estimate=msl::to_int(task_json.get("time_estimate"));
temp_task.time_working=msl::to_int(task_json.get("time_working"));
temp_list.push_back(temp_task);
}
list_=temp_list;
return true;
}
return false;
}
Mesh* json_parse_mesh(const jsonvalue& json) {
auto mesh = new Mesh();
if(json.object_contains("json_mesh")) {
json_texture_path_push(json.object_element("json_mesh").as_string());
mesh = json_parse_mesh(load_json(json.object_element("json_mesh").as_string()));
json_texture_path_pop();
}
json_set_optvalue(json, mesh->frame, "frame");
json_set_optvalue(json, mesh->pos, "pos");
json_set_optvalue(json, mesh->norm, "norm");
json_set_optvalue(json, mesh->texcoord, "texcoord");
json_set_optvalue(json, mesh->triangle, "triangle");
json_set_optvalue(json, mesh->quad, "quad");
json_set_optvalue(json, mesh->point, "point");
json_set_optvalue(json, mesh->line, "line");
json_set_optvalue(json, mesh->spline, "spline");
if(json.object_contains("material")) mesh->mat = json_parse_material(json.object_element("material"));
json_set_optvalue(json, mesh->subdivision_catmullclark_level, "subdivision_catmullclark_level");
json_set_optvalue(json, mesh->subdivision_catmullclark_smooth, "subdivision_catmullclark_smooth");
json_set_optvalue(json, mesh->subdivision_bezier_level, "subdivision_bezier_level");
json_set_optvalue(json, mesh->subdivision_bezier_uniform, "subdivision_bezier_uniform");
if(json.object_contains("animation")) mesh->animation = json_parse_frame_animation(json.object_element("animation"));
if(json.object_contains("skinning")) mesh->skinning = json_parse_mesh_skinning(json.object_element("skinning"));
if(json.object_contains("json_skinning")) mesh->skinning = json_parse_mesh_skinning(load_json(json.object_element("json_skinning").as_string()));
if(json.object_contains("simulation")) mesh->simulation = json_parse_mesh_simulation(json.object_element("simulation"));
if (mesh->skinning) {
if (mesh->skinning->vert_rest_pos.empty()) mesh->skinning->vert_rest_pos = mesh->pos;
if (mesh->skinning->vert_rest_norm.empty()) mesh->skinning->vert_rest_norm = mesh->norm;
if (mesh->pos.empty()) mesh->pos = mesh->skinning->vert_rest_pos;
if (mesh->norm.empty()) mesh->norm = mesh->skinning->vert_rest_norm;
}
return mesh;
}
bool load_opentyrian_config( void )
{
// defaults
fullscreen_enabled = false;
#ifdef __BLACKBERRY__
#else
set_scaler_by_name("3x");
#ifdef ENABLE_CONFIGURATION
cJSON *root = load_json("opentyrian.conf");
if (root == NULL)
return false;
cJSON *section = cJSON_GetObjectItem(root, "video");
if (section != NULL)
{
cJSON *setting;
if ((setting = cJSON_GetObjectItem(section, "fullscreen")))
fullscreen_enabled = (setting->type == cJSON_True);
if ((setting = cJSON_GetObjectItem(section, "scaler")))
set_scaler_by_name(setting->valuestring);
}
cJSON_Delete(root);
#endif /*ENABLE_CONFIGURATION*/
#endif
return true;
}
/**
* Answers /Hash_Array.json POST request by answering to the client needed
* hashs
* @param server_struct is the main structure for the server.
* @param connection is the connection in MHD
* @param received_data is a gchar * string to the data that was received
* by the POST request.
*/
static int answer_hash_array_post_request(server_struct_t *server_struct, struct MHD_Connection *connection, gchar *received_data)
{
gchar *answer = NULL; /** gchar *answer : Do not free answer variable as MHD will do it for us ! */
json_t *root = NULL; /** json_t *root is the root that will contain all meta data json formatted */
json_t *array = NULL; /** json_t *array is the array that will receive base64 encoded hashs */
GList *hash_data_list = NULL;
if (server_struct != NULL && connection != NULL && received_data != NULL)
{
root = load_json(received_data);
hash_data_list = extract_glist_from_array(root, "hash_list", TRUE);
json_decref(root);
print_debug(_("Received hash array of %zd bytes size\n"), strlen(received_data));
array = find_needed_hashs(server_struct, hash_data_list);
root = json_object();
insert_json_value_into_json_root(root, "hash_list", array);
answer = json_dumps(root, 0);
json_decref(root);
g_list_free_full(hash_data_list, free_hdt_struct);
}
else
{
answer = g_strdup_printf(_("Error: could not convert json to metadata\n"));
}
return create_MHD_response(connection, answer);
}
bool save_opentyrian_config( void )
{
#ifdef __BLACKBERRY__
#else
#ifdef ENABLE_CONFIGURATION
cJSON *root = load_json("opentyrian.conf");
if (root == NULL)
root = cJSON_CreateObject();
cJSON *section;
section = cJSON_CreateOrGetObjectItem(root, "video");
cJSON_ForceType(section, cJSON_Object);
{
cJSON *setting;
setting = cJSON_CreateOrGetObjectItem(section, "fullscreen");
cJSON_SetBoolean(setting, fullscreen_enabled);
setting = cJSON_CreateOrGetObjectItem(section, "scaler");
cJSON_SetString(setting, scalers[scaler].name);
}
save_json(root, "opentyrian.conf");
cJSON_Delete(root);
#endif /*ENABLE_CONFIGURATION*/
#endif
return true;
}
Scene* json_parse_scene(const jsonvalue& json) {
// prepare scene
auto scene = new Scene();
// camera
if (json.object_contains("camera")) scene->camera = json_parse_camera(json.object_element("camera"));
if (json.object_contains("lookat_camera")) scene->camera = json_parse_lookatcamera(json.object_element("lookat_camera"));
// surfaces
if(json.object_contains("surfaces")) scene->surfaces = json_parse_surfaces(json.object_element("surfaces"));
// meshes
if(json.object_contains("json_meshes")) {
json_texture_path_push(json.object_element("json_meshes").as_string());
scene->meshes = json_parse_meshes(load_json(json.object_element("json_meshes").as_string()));
json_texture_path_pop();
}
if(json.object_contains("meshes")) {
scene->meshes = json_parse_meshes(json.object_element("meshes"));
}
// lights
if(json.object_contains("lights")) scene->lights = json_parse_lights(json.object_element("lights"));
// animation
if(json.object_contains("animation")) scene->animation = json_parse_scene_animation(json.object_element("animation"));
// rendering parameters
json_set_optvalue(json, scene->image_width, "image_width");
json_set_optvalue(json, scene->image_height, "image_height");
json_set_optvalue(json, scene->image_samples, "image_samples");
json_set_optvalue(json, scene->background, "background");
json_parse_opttexture(json, scene->background_txt, "background_txt");
json_set_optvalue(json, scene->ambient, "ambient");
json_set_optvalue(json, scene->path_max_depth, "path_max_depth");
json_set_optvalue(json, scene->path_sample_brdf, "path_sample_brdf");
json_set_optvalue(json, scene->path_shadows, "path_shadows");
// done
return scene;
}
esdm_config_t* esdm_config_init_from_str(const char * config_str){
esdm_config_t* config = NULL;
config = (esdm_config_t*) malloc(sizeof(esdm_config_t));
config->json = load_json(config_str); // parse text into JSON structure
return config;
}
bool load_opentyrian_config( void )
{
// defaults
fullscreen_enabled = false;
set_scaler_by_name("Scale2x");
cJSON *root = load_json("opentyrian.conf");
if (root == NULL)
return false;
cJSON *section = cJSON_GetObjectItem(root, "video");
if (section != NULL)
{
cJSON *setting;
if ((setting = cJSON_GetObjectItem(section, "fullscreen")))
fullscreen_enabled = (setting->type == cJSON_True);
if ((setting = cJSON_GetObjectItem(section, "scaler")))
set_scaler_by_name(setting->valuestring);
}
cJSON_Delete(root);
return true;
}
bool save_opentyrian_config( void )
{
cJSON *root = load_json("opentyrian.conf");
if (root == NULL)
root = cJSON_CreateObject();
cJSON *section;
section = cJSON_CreateOrGetObjectItem(root, "video");
cJSON_ForceType(section, cJSON_Object);
{
cJSON *setting;
setting = cJSON_CreateOrGetObjectItem(section, "fullscreen");
cJSON_SetBoolean(setting, fullscreen_enabled);
setting = cJSON_CreateOrGetObjectItem(section, "scaler");
cJSON_SetString(setting, scalers[scaler].name);
}
save_json(root, "opentyrian.conf");
cJSON_Delete(root);
return true;
}
Scene* load_json_scene(const string& filename) {
json_texture_cache.clear();
json_texture_paths = { "" };
auto scene = json_parse_scene(load_json(filename));
json_texture_cache.clear();
json_texture_paths = { "" };
return scene;
}
void display ( void )
{
load_json("elements.json");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glTranslatef(x,y,z);
glColor3f(1.0,0.0,0.0);
glPointSize(10.0);
glBegin(GL_TRIANGLES);
glVertex2f(-0.8f,-0.8f);
glVertex2f(0.0f,0.8f);
glVertex2f(0.8f,-0.8f);
glEnd();
counter++;
if(counter == 1000) define_direction();
glFlush();
glutSwapBuffers();
}
Result json_to_vb_pair(const char *fname, Pair *o_pair)
{
Result result;
json_value* value;
value = NULL;
result.parse_result.status = PS_NO_PARSE;
result.parse_result.emsg = "Not yet initialized";
result.file_result = load_json(fname, &value);
if (result.file_result.status != FS_SUCCESS) {
return result;
}
result.parse_result = check_json(value);
if (result.parse_result.status != PS_SUCCESS) {
json_value_free(value);
return result;
}
VertexSetPointer vs; BondSetPointer bs;
vs = (VertexSetPointer) Util_allocate(1, sizeof(VertexSet));
result.parse_result = vertexset_from_json(value, &vs);
if (result.parse_result.status != PS_SUCCESS) {
json_value_free(value);
return result;
}
bs = (BondSetPointer) Util_allocate(1, sizeof(BondSet));
result.parse_result = bondset_from_json(*vs, value, &bs);
if (result.parse_result.status != PS_SUCCESS) {
json_value_free(value);
return result;
}
if (value != NULL) {
json_value_free(value);
}
*o_pair = Pair_initialize(vs, bs);
return result;
}
bool load_joystick_assignments( int j )
{
cJSON *root = load_json("joystick.conf");
if (root == NULL)
return false;
cJSON *config = cJSON_GetObjectItem(root, SDL_JoystickName(j));
if (config == NULL)
{
cJSON_Delete(root);
return false;
}
cJSON *setting;
if ((setting = cJSON_GetObjectItem(config, "analog")))
joystick[j].analog = (setting->type == cJSON_True);
if ((setting = cJSON_GetObjectItem(config, "sensitivity")))
joystick[j].sensitivity = setting->valueint;
if ((setting = cJSON_GetObjectItem(config, "threshold")))
joystick[j].threshold = setting->valueint;
if ((setting = cJSON_GetObjectItem(config, "assignments")))
{
for (uint i = 0; i < COUNTOF(joystick->assignment); ++i)
{
cJSON *assignments = cJSON_GetArrayItem(setting, i);
if (assignments == NULL)
break;
for (uint k = 0; k < COUNTOF(*joystick->assignment); ++k)
{
cJSON *assignment = cJSON_GetArrayItem(assignments, k);
if (assignment)
code_to_assignment(&joystick[j].assignment[i][k], assignment->valuestring);
}
}
}
cJSON_Delete(root);
return true;
}
/**
*
*
* @return Status
*/
esdm_status esdm_layout_stat(char* desc)
{
ESDM_DEBUG(__func__);
ESDM_DEBUG("received metadata lookup request");
// parse text into JSON structure
json_t *root = load_json(desc);
if (root) {
// print and release the JSON structure
print_json(root);
json_decref(root);
}
return ESDM_SUCCESS;
}
bool save_joystick_assignments( int j )
{
cJSON *root = load_json("joystick.conf");
if (root == NULL)
root = cJSON_CreateObject();
cJSON *config = cJSON_CreateOrGetObjectItem(root, SDL_JoystickName(j));
cJSON_ForceType(config, cJSON_Object);
cJSON *setting;
setting = cJSON_CreateOrGetObjectItem(config, "analog");
cJSON_SetBoolean(setting, joystick[j].analog);
setting = cJSON_CreateOrGetObjectItem(config, "sensitivity");
cJSON_SetNumber(setting, joystick[j].sensitivity);
setting = cJSON_CreateOrGetObjectItem(config, "threshold");
cJSON_SetNumber(setting, joystick[j].threshold);
setting = cJSON_CreateOrGetObjectItem(config, "assignments");
cJSON_ForceType(setting, cJSON_Array);
cJSON_ClearArray(setting);
for (uint i = 0; i < COUNTOF(joystick->assignment); ++i)
{
cJSON *assignments;
cJSON_AddItemToArray(setting, assignments = cJSON_CreateArray());
for (uint k = 0; k < COUNTOF(*joystick->assignment); ++k)
{
if (joystick[j].assignment[i][k].type == NONE)
continue;
cJSON_AddItemToArray(assignments, cJSON_CreateString(assignment_to_code(&joystick[j].assignment[i][k])));
}
}
save_json(root, "joystick.conf");
cJSON_Delete(root);
return true;
}
void inviteMsg(TPTransportCTX *context, char* username) {
TPUserID userID;
TPTransportMsg *message;
memset(&userID, 0, sizeof(userID));
strcpy((char*)userID,username);
if (strcmp((char *)&userID, "NULL") != 0) {
message = TPMsgGet(context, &userID, TP_MSG_TYPE_CHATCONTROL);
}
else {
message = TPMsgGet(context, NULL, TP_MSG_TYPE_CHATCONTROL);
}
if (message != NULL) {
message->msg[message->bytesCount] = '\0';
printf("'%s'->'%s': '%s' @%lu\n", message->from, message->to, message->msg, message->timestamp);
TPGroupID groupRef;
memset(&groupRef, 0, sizeof(groupRef));
// strcpy((char *)groupRef,message->msg);
// printf("json-msg(recv): %s\n",message->msg);
json_t *root = load_json(message->msg);
json_t *result = json_object_get(root,"groupID");
char* myresult = (char*)json_string_value(result);
strcpy((char *)groupRef,myresult);
int ret = TPGroupJoin(context, &userID, &groupRef);
if (ret != 0) {
fprintf(stderr, "Client joinGroup return (%d)\n", ret);
}
else{
printf("'%s' join group '%s' done!!\n",userID,groupRef);
}
TPMsgFree(message);
} else {
// printf("not found message\n");
}
}
qdb cmd_t::toquads ( const strings& args ) {
return toquads ( load_json ( args ) );
}
qdb cmd_t::convert ( const string& s ) {
if ( fnamebase ) opts.base = pstr ( string ( L"file://" ) + s + L"#" );
qdb r = convert ( load_json ( s ) );
return r;
}
int main(int argc, char *argv[])
{
char ch;
char str[STR_BUFFSIZE];
char plom_help_string[] =
"PLOM ksimplex\n"
"usage:\n"
"ksimplex [implementation] [--no_dem_sto] [--no_white_noise] [--no_diff]\n"
" [-s, --DT <float>] [--eps_abs <float>] [--eps_rel <float>]\n"
" [-p, --path <path>] [-i, --id <integer>]\n"
" [-g, --freeze_forcing <float>]\n"
" [--prior] [--transf]\n"
" [-l, --LIKE_MIN <float>] [-S, --size <float>] [-M, --iter <integer>]\n"
" [-q, --quiet] [-P, --pipe]"
" [-h, --help]\n"
"where implementation is 'sde' (default)\n"
"options:\n"
"\n"
"-q, --quiet no verbosity\n"
"-P, --pipe pipe mode (echo theta.json on stdout)\n"
"\n"
"--no_dem_sto turn off demographic stochasticity (if possible)\n"
"--no_white_noise turn off environmental stochasticity (if any)\n"
"--no_diff turn off drift (if any)\n"
"\n"
"-s, --DT Initial integration time step\n"
"--eps_abs Absolute error for adaptive step-size control\n"
"--eps_rel Relative error for adaptive step-size control\n"
"-g, --freeze_forcing freeze the metadata to their value at the specified time\n"
"\n"
"--prior to maximize posterior density in natural space\n"
"--transf to maximize posterior density in transformed space (if combined with --prior)\n"
"-p, --path path where the outputs will be stored\n"
"-i, --id general id (unique integer identifier that will be appended to the output files)\n"
"-l, --LIKE_MIN particles with likelihood smaller that LIKE_MIN are considered lost\n"
"-M, --iter maximum number of iterations\n"
"-S, --size simplex size used as a stopping criteria\n"
"-b, --no_traces do not write the traces\n"
"-o, --nb_obs number of observations to be fitted (for tempering)"
"--help print the usage on stdout\n";
// simplex options
M = 10;
CONVERGENCE_STOP_SIMPLEX = 1e-6;
// general options
GENERAL_ID =0;
snprintf(SFR_PATH, STR_BUFFSIZE, "%s", DEFAULT_PATH);
J=1;
LIKE_MIN = 1e-17;
LOG_LIKE_MIN = log(1e-17);
int nb_obs = -1;
double freeze_forcing = -1.0;
// options
OPTION_PRIOR = 0;
OPTION_TRANSF = 0;
double dt = 0.0, eps_abs = PLOM_EPS_ABS, eps_rel = PLOM_EPS_REL;
enum plom_print print_opt = PLOM_PRINT_BEST;
enum plom_implementations implementation;
enum plom_noises_off noises_off = 0;
static struct option long_options[] = {
{"help", no_argument, 0, 'h'},
{"no_trace", no_argument, 0, 'b'},
{"no_dem_sto", no_argument, 0, 'x'},
{"no_white_noise", no_argument, 0, 'y'},
{"no_diff", no_argument, 0, 'z'},
{"DT", required_argument, 0, 's'},
{"eps_abs", required_argument, 0, 'v'},
{"eps_rel", required_argument, 0, 'w'},
{"freeze_forcing", required_argument, 0, 'g'},
{"path", required_argument, 0, 'p'},
{"id", required_argument, 0, 'i'},
{"prior", no_argument, &OPTION_PRIOR, 1},
{"transf", no_argument, &OPTION_TRANSF, 1},
{"LIKE_MIN", required_argument, 0, 'l'},
{"iter", required_argument, 0, 'M'},
{"size", required_argument, 0, 'S'},
{"nb_obs", required_argument, 0, 'o'},
{"quiet", no_argument, 0, 'q'},
{"pipe", no_argument, 0, 'P'},
{0, 0, 0, 0}
};
int option_index = 0;
while ((ch = getopt_long (argc, argv, "qPhxyzs:v:w:i:l:p:S:M:o:bg:", long_options, &option_index)) != -1) {
switch (ch) {
case 0:
break;
case 'x':
noises_off = noises_off | PLOM_NO_DEM_STO;
break;
case 'y':
noises_off = noises_off | PLOM_NO_ENV_STO;
break;
case 'z':
noises_off = noises_off | PLOM_NO_DRIFT;
break;
case 's':
dt = atof(optarg);
break;
case 'v':
eps_abs = atof(optarg);
break;
case 'w':
eps_rel = atof(optarg);
break;
case 'h':
print_log(plom_help_string);
return 1;
case 'b':
print_opt &= ~PLOM_PRINT_BEST;
break;
case 'p':
snprintf(SFR_PATH, STR_BUFFSIZE, "%s", optarg);
break;
case 'i':
GENERAL_ID = atoi(optarg);
break;
case 'g':
freeze_forcing = atof(optarg);
break;
case 'o':
nb_obs = atoi(optarg);
break;
case 'l':
LIKE_MIN = atof(optarg);
LOG_LIKE_MIN = log(LIKE_MIN);
break;
case 'M':
M = atoi(optarg);
break;
case 'S':
CONVERGENCE_STOP_SIMPLEX = atof(optarg);
break;
case 'q':
print_opt |= PLOM_QUIET;
break;
case 'P':
print_opt |= PLOM_PIPE | PLOM_QUIET;
break;
case '?':
/* getopt_long already printed an error message. */
return 1;
default:
snprintf(str, STR_BUFFSIZE, "Unknown option '-%c'\n", optopt);
print_err(str);
return 1;
}
}
argc -= optind;
argv += optind;
if(argc == 0) {
implementation = PLOM_ODE; //with Kalman the SDE uses f_pred of PLOM_ODE (OK will do better)...
} else {
if (!strcmp(argv[0], "sde")) {
implementation = PLOM_ODE;
} else {
print_log(plom_help_string);
return 1;
}
}
plom_unlink_done(SFR_PATH, GENERAL_ID);
json_t *settings = load_settings(PATH_SETTINGS);
int64_t time_begin, time_end;
if (!(print_opt & PLOM_QUIET)) {
snprintf(str, STR_BUFFSIZE, "Starting plom-ksimplex with the following options: i = %d, LIKE_MIN = %g", GENERAL_ID, LIKE_MIN);
print_log(str);
time_begin = s_clock();
}
json_t *theta = load_json();
struct s_kalman *p_kalman = build_kalman(theta, settings, implementation, noises_off, OPTION_PRIOR, dt, eps_abs, eps_rel, freeze_forcing, nb_obs);
json_decref(settings);
simplex(p_kalman->p_best, p_kalman->p_data, p_kalman, f_simplex_kalman, CONVERGENCE_STOP_SIMPLEX, M, print_opt);
if (!(print_opt & PLOM_QUIET)) {
time_end = s_clock();
struct s_duration t_exec = time_exec(time_begin, time_end);
snprintf(str, STR_BUFFSIZE, "Done in:= %dd %dh %dm %gs", t_exec.d, t_exec.h, t_exec.m, t_exec.s);
print_log(str);
}
plom_print_done(theta, p_kalman->p_data, p_kalman->p_best, SFR_PATH, GENERAL_ID, print_opt);
if (!(print_opt & PLOM_QUIET)) {
print_log("clean up...");
}
json_decref(theta);
clean_kalman(p_kalman);
return 0;
}
/**
* Function that process the received data from the POST command and
* answers to the client.
* Here we may do something with this data (we may want to store it
* somewhere).
*
* @param server_struct is the main structure for the server.
* @param connection is the connection in MHD
* @param url is the requested url
* @param received_data is a gchar * string to the data that was received
* by the POST request.
*/
static int process_received_data(server_struct_t *server_struct, struct MHD_Connection *connection, const char *url, gchar *received_data)
{
gchar *answer = NULL; /** gchar *answer : Do not free answer variable as MHD will do it for us ! */
int success = MHD_NO;
gboolean debug = FALSE;
hash_data_t *hash_data = NULL;
json_t *root = NULL;
GList *hash_data_list = NULL;
GList *head = NULL;
a_clock_t *elapsed = NULL;
if (g_strcmp0(url, "/Meta.json") == 0 && received_data != NULL)
{
success = answer_meta_json_post_request(server_struct, connection, received_data);
}
else if (g_strcmp0(url, "/Hash_Array.json") == 0 && received_data != NULL)
{
success = answer_hash_array_post_request(server_struct, connection, received_data);
/* Here we will try to answer which hashs are needed and then
* send thoses hashs back in the answer
*/
}
else if (g_strcmp0(url, "/Data.json") == 0 && received_data != NULL)
{
hash_data = convert_string_to_hash_data(received_data);
if (get_debug_mode() == TRUE)
{
print_received_data_for_hash(hash_data->hash, hash_data->read);
}
/**
* Sending received_data into the queue in order to be treated by
* the corresponding thread. hash_data is freed by data_thread
* and should not be used after this "call" here.
*/
g_async_queue_push(server_struct->data_queue, hash_data);
/**
* creating an answer for the client to say that everything went Ok!
*/
answer = g_strdup_printf(_("Ok!"));
success = create_MHD_response(connection, answer);
}
else if (g_strcmp0(url, "/Data_Array.json") == 0 && received_data != NULL)
{
/* print_debug("/Data_Array.json: %s\n", received_data); */
elapsed = new_clock_t();
root = load_json(received_data);
end_clock(elapsed, "load_json");
hash_data_list = extract_glist_from_array(root, "data_array", FALSE);
head = hash_data_list;
json_decref(root);
debug = get_debug_mode();
while (hash_data_list != NULL)
{
hash_data = hash_data_list->data;
if (debug == TRUE)
{
/* Only for debbugging ! */
print_received_data_for_hash(hash_data->hash, hash_data->read);
}
/** Sending hash_data into the queue. */
g_async_queue_push(server_struct->data_queue, hash_data);
hash_data_list = g_list_next(hash_data_list);
}
g_list_free(head);
/**
* creating an answer for the client to say that everything went Ok!
*/
answer = g_strdup_printf(_("Ok!"));
success = create_MHD_response(connection, answer);
}
else
{
/* The url is unknown to the server and we can not process the request ! */
print_error(__FILE__, __LINE__, "Error: invalid url: %s\n", url);
answer = g_strdup_printf(_("Error: invalid url!\n"));
success = create_MHD_response(connection, answer);
}
return success;
}
/**
* Sends data as requested by the server 'cdpfglserver'.
* @param main_struct : main structure of the program.
* @param hash_data_list : list of hash_data_t * pointers containing
* all the data to be saved.
* @param answer is the request sent back by server when we had send
* meta data.
* @note using directly main_struct->comm->buffer -> not threadable as is.
*/
static GList *send_data_to_server(main_struct_t *main_struct, GList *hash_data_list, gchar *answer)
{
json_t *root = NULL;
GList *hash_list = NULL; /** hash_list is local to this function */
GList *head = NULL;
gint success = CURLE_FAILED_INIT;
GList *iter = NULL;
hash_data_t *found = NULL;
hash_data_t *hash_data = NULL;
if (main_struct != NULL && main_struct->comm != NULL && answer != NULL && hash_data_list!= NULL)
{
root = load_json(answer);
if (root != NULL)
{
/* This hash_list is the needed hashs from server */
hash_list = extract_glist_from_array(root, "hash_list", TRUE);
json_decref(root);
head = hash_list;
while (hash_list != NULL)
{
hash_data = hash_list->data;
/* hash_data_list contains all hashs and their associated data */
iter = find_hash_in_list(hash_data_list, hash_data->hash);
found = iter->data;
/* readbuffer is the buffer sent to server */
main_struct->comm->readbuffer = convert_hash_data_t_to_string(found);
success = post_url(main_struct->comm, "/Data.json");
if (success != CURLE_OK)
{
db_save_buffer(main_struct->database, "/Data.json", main_struct->comm->readbuffer);
}
free_variable(main_struct->comm->readbuffer);
hash_data_list = g_list_remove_link(hash_data_list, iter);
/* iter is now a single element list and we can delete
* data in this element and then remove this single element list
*/
g_list_free_full(iter, free_hdt_struct);
main_struct->comm->buffer = free_variable(main_struct->comm->buffer);
hash_list = g_list_next(hash_list);
}
if (head != NULL)
{
g_list_free_full(head, free_hdt_struct);
}
}
else
{
print_error(__FILE__, __LINE__, _("Error while loading JSON answer from server\n"));
}
}
return hash_data_list;
}
/**
* Sends data as requested by the server 'cdpfglserver' in a buffered way.
* @param main_struct : main structure of the program.
* @param hash_data_list : list of hash_data_t * pointers containing
* all the data to be saved.
* @param answer is the request sent back by server when we had send
* meta data.
* @note using directly main_struct->comm->buffer -> not threadable as is.
*/
static GList *send_all_data_to_server(main_struct_t *main_struct, GList *hash_data_list, gchar *answer)
{
json_t *root = NULL;
json_t *array = NULL;
GList *hash_list = NULL; /** hash_list is local to this function and contains the needed hashs as answer by server */
GList *head = NULL;
GList *iter = NULL;
hash_data_t *found = NULL;
hash_data_t *hash_data = NULL;
gint bytes = 0;
json_t *to_insert = NULL;
gint64 limit = 0;
a_clock_t *elapsed = NULL;
if (answer != NULL && hash_data_list != NULL && main_struct != NULL && main_struct->opt != NULL)
{
root = load_json(answer);
limit = main_struct->opt->buffersize;
if (root != NULL)
{
/* This hash_list is the needed hashs from server */
hash_list = extract_glist_from_array(root, "hash_list", TRUE);
json_decref(root);
array = json_array();
head = hash_list;
while (hash_list != NULL)
{
hash_data = hash_list->data;
/* hash_data_list contains all hashs and their associated data for the file
* being processed */
iter = find_hash_in_list(hash_data_list, hash_data->hash);
found = iter->data;
to_insert = convert_hash_data_t_to_json(found);
json_array_append_new(array, to_insert);
bytes = bytes + found->read;
hash_data_list = g_list_remove_link(hash_data_list, iter);
/* iter is now a single element list and we can delete
* data in this element and then remove this single element list
*/
g_list_free_full(iter, free_hdt_struct);
if (bytes >= limit)
{
/* when we've got opt->buffersize bytes of data send them ! */
elapsed = new_clock_t();
insert_array_in_root_and_send(main_struct, array);
array = json_array();
bytes = 0;
end_clock(elapsed, "insert_array_in_root_and_send");
}
hash_list = g_list_next(hash_list);
}
if (bytes > 0)
{
/* Send the rest of the data (less than opt->buffersize bytes) */
elapsed = new_clock_t();
insert_array_in_root_and_send(main_struct, array);
end_clock(elapsed, "insert_array_in_root_and_send");
}
else
{
json_decref(array);
}
if (head != NULL)
{
g_list_free_full(head, free_hdt_struct);
}
}
else
{
print_error(__FILE__, __LINE__, _("Error while loading JSON answer from server\n"));
}
}
return hash_data_list;
}
pobj cmd_t::nodemap ( const strings& args ) {
return nodemap ( load_json ( args[2] ) );
}
Scene* load_json_scene(const string& filename) {
auto scene = json_parse_scene(load_json(filename));
return scene;
}
esdm_status esdm_scheduler_enqueue_read(esdm_instance_t *esdm, io_request_status_t * status, int frag_count, esdm_fragment_t** read_frag, void * buf, esdm_dataspace_t * buf_space){
GError * error;
status->pending_ops += frag_count;
int i, x;
for (i = 0; i < frag_count; i++){
esdm_fragment_t * f = read_frag[i];
json_t *root = load_json(f->metadata->json);
json_t * elem;
elem = json_object_get(root, "plugin");
//const char * plugin_type = json_string_value(elem);
elem = json_object_get(root, "id");
const char * plugin_id = json_string_value(elem);
elem = json_object_get(root, "offset");
//const char * offset_str = json_string_value(elem);
elem = json_object_get(root, "size");
//const char * size_str = json_string_value(elem);
if(!plugin_id){
printf("Backend ID needs to be given\n");
exit(1);
}
// find the backend for the fragment
esdm_backend* backend_to_use = NULL;
for (x = 0; x < esdm->modules->backend_count; x++){
esdm_backend* b_tmp = esdm->modules->backends[x];
if (strcmp(b_tmp->config->id, plugin_id) == 0){
DEBUG("Found plugin %s", plugin_id);
backend_to_use = b_tmp;
break;
}
}
if(backend_to_use == NULL){
printf("Error no backend found for ID: %s\n", plugin_id);
exit(1);
}
// esdm_fragment_print(read_frag[i]);
// printf("\n");
DEBUG("OFFSET/SIZE: %s %s\n", offset_str, size_str);
//for verification purposes, we could read back the metadata stored and compare it...
//esdm_dataspace_t * space = NULL;
//esdm_status ret = esdm_dataspace_overlap_str(parent_space, 'x', (char*)offset_str, (char*)size_str, & space);
//assert(ret == ESDM_SUCCESS);
uint64_t size = esdm_dataspace_size(f->dataspace);
//printf("SIZE: %ld\n", size);
f->backend = backend_to_use;
io_work_t * task = (io_work_t*) malloc(sizeof(io_work_t));
task->parent = status;
task->op = ESDM_OP_READ;
task->fragment = f;
if(f->in_place){
DEBUG("inplace!", "");
task->callback = NULL;
f->buf = buf;
}else{
f->buf = malloc(size);
task->callback = read_copy_callback;
task->data.mem_buf = buf;
task->data.buf_space = buf_space;
}
if (backend_to_use->threads == 0){
backend_thread(task, backend_to_use);
}else{
g_thread_pool_push(backend_to_use->threadPool, task, & error);
}
}
return ESDM_SUCCESS;
}
pobj cmd_t::load_json ( const strings& args ) {
return load_json ( args.size() > 2 ? args[2] : L"" );
}
int main(int argc, char *argv[])
{
char ch;
char str[STR_BUFFSIZE];
char plom_help_string[] =
"PLOM Kalman\n"
"usage:\n"
"kalman [implementation] [--no_dem_sto] [--no_white_noise] [--no_diff]\n"
" [-s, --DT <float>] [--eps_abs <float>] [--eps_rel <float>]\n"
" [-g, --freeze_forcing <float>]\n"
" [-r, --traj] [-p, --path <path>] [-i, --id <integer>]\n"
" [-b, --no_trace] [-e, --no_hat] [--prior] [--transf]\n"
" [-q, --quiet] [-P, --pipe]"
" [-h, --help]\n"
"where implementation is 'sde' (default)\n"
"options:\n"
"\n"
"-q, --quiet no verbosity\n"
"-P, --pipe pipe mode (echo theta.json on stdout)\n"
"\n"
"--no_dem_sto turn off demographic stochasticity (if possible)\n"
"--no_white_noise turn off environmental stochasticity (if any)\n"
"--no_diff turn off drift (if any)\n"
"\n"
"-s, --DT Initial integration time step\n"
"--eps_abs Absolute error for adaptive step-size contro\n"
"--eps_rel Relative error for adaptive step-size contro\n"
"-g, --freeze_forcing freeze the metadata to their value at the specified time\n"
"\n"
"-r, --traj print the trajectories\n"
"--prior add log(prior) to the estimated loglik\n"
"--transf add log(JacobianDeterminant(transf)) to the estimated loglik. (combined to --prior, gives posterior density in transformed space)\n"
"-p, --path path where the outputs will be stored\n"
"-b, --no_trace do not write trace_<id>.output file\n"
"-h, --no_hat do not write hat_<general_id>.output file\n"
"-d, --no_pred_res do not write pred_res_<general_id>.output file (prediction residuals)\n"
"-i, --id general id (unique integer identifier that will be appended to the output files)\n"
"-l, --LIKE_MIN particles with likelihood smaller that LIKE_MIN are considered lost\n"
"-o, --nb_obs number of observations to be fitted (for tempering)"
"-h, --help print the usage on stdout\n";
// general options
GENERAL_ID =0;
snprintf(SFR_PATH, STR_BUFFSIZE, "%s", DEFAULT_PATH);
LIKE_MIN = 1e-17;
LOG_LIKE_MIN = log(LIKE_MIN);
enum plom_print print_opt = PLOM_PRINT_BEST | PLOM_PRINT_HAT | PLOM_PRINT_PRED_RES;
// options
OPTION_PRIOR = 0;
OPTION_TRANSF = 0;
int nb_obs = -1;
double freeze_forcing = -1.0;
double dt = 0.0, eps_abs = PLOM_EPS_ABS, eps_rel = PLOM_EPS_REL;
J = 1; //not an option, needed for print_X
enum plom_implementations implementation;
enum plom_noises_off noises_off = 0;
static struct option long_options[] = {
{"traj", no_argument, 0, 'r'},
{"no_dem_sto", no_argument, 0, 'x'},
{"no_white_noise", no_argument, 0, 'y'},
{"no_diff", no_argument, 0, 'z'},
{"DT", required_argument, 0, 's'},
{"eps_abs", required_argument, 0, 'v'},
{"eps_rel", required_argument, 0, 'w'},
{"freeze_forcing", required_argument, 0, 'g'},
{"help", no_argument, 0, 'h'},
{"path", required_argument, 0, 'p'},
{"id", required_argument, 0, 'i'},
{"no_trace", no_argument, 0, 'b'},
{"no_hat", no_argument, 0, 'e'},
{"no_pred_res",no_argument, 0, 'd'},
{"prior", no_argument, &OPTION_PRIOR, 1},
{"transf", no_argument, &OPTION_TRANSF, 1},
{"nb_obs", required_argument, 0, 'o'},
{"quiet", no_argument, 0, 'q'},
{"pipe", no_argument, 0, 'P'},
{"LIKE_MIN", required_argument, 0, 'l'},
{0, 0, 0, 0}
};
int option_index = 0;
while ((ch = getopt_long (argc, argv, "qPxyzs:v:w:i:l:p:rbhedo:g:", long_options, &option_index)) != -1) {
switch (ch) {
case 0:
break;
case 'x':
noises_off = noises_off | PLOM_NO_DEM_STO;
break;
case 'y':
noises_off = noises_off | PLOM_NO_ENV_STO;
break;
case 'z':
noises_off = noises_off | PLOM_NO_DRIFT;
break;
case 'o':
nb_obs = atoi(optarg);
break;
case 'g':
freeze_forcing = atof(optarg);
break;
case 's':
dt = atof(optarg);
break;
case 'v':
eps_abs = atof(optarg);
break;
case 'w':
eps_rel = atof(optarg);
break;
case 'h':
print_log(plom_help_string);
return 1;
case 'p':
snprintf(SFR_PATH, STR_BUFFSIZE, "%s", optarg);
break;
case 'i':
GENERAL_ID = atoi(optarg);
break;
case 'l':
LIKE_MIN = atof(optarg);
LOG_LIKE_MIN = log(LIKE_MIN);
break;
case 'r':
print_opt |= PLOM_PRINT_X;
break;
case 'b':
print_opt &= ~PLOM_PRINT_BEST;
break;
case 'e':
print_opt &= ~PLOM_PRINT_HAT;
break;
case 'd':
print_opt &= ~PLOM_PRINT_PRED_RES;
break;
case 'q':
print_opt |= PLOM_QUIET;
break;
case 'P':
print_opt |= PLOM_PIPE | PLOM_QUIET;
break;
case '?':
/* getopt_long already printed an error message. */
return 1;
default:
snprintf(str, STR_BUFFSIZE, "Unknown option '-%c'\n", optopt);
print_err(str);
return 1;
}
}
argc -= optind;
argv += optind;
if(argc == 0) {
implementation = PLOM_ODE; //with Kalman the SDE uses f_pred of PLOM_ODE (OK will do better)...
} else {
if (!strcmp(argv[0], "sde")) {
implementation = PLOM_ODE;
} else {
print_log(plom_help_string);
return 1;
}
}
plom_unlink_done(SFR_PATH, GENERAL_ID);
json_t *settings = load_settings(PATH_SETTINGS);
if (!(print_opt & PLOM_QUIET)) {
snprintf(str, STR_BUFFSIZE, "Starting plom-Kalman with the following options: i = %d, LIKE_MIN = %g", GENERAL_ID, LIKE_MIN);
print_log(str);
}
json_t *theta = load_json();
struct s_kalman *p_kalman = build_kalman(theta, settings, implementation, noises_off, OPTION_PRIOR, dt, eps_abs, eps_rel, freeze_forcing, nb_obs);
json_decref(settings);
int64_t time_begin, time_end;
if (!(print_opt & PLOM_QUIET)) {
time_begin = s_clock();
}
back_transform_theta2par(p_kalman->p_par, p_kalman->p_best->mean, p_kalman->p_data->p_it_all, p_kalman->p_data);
linearize_and_repeat(p_kalman->p_X, p_kalman->p_par, p_kalman->p_data, p_kalman->p_data->p_it_par_sv);
prop2Xpop_size(p_kalman->p_X, p_kalman->p_data, p_kalman->calc[0]);
theta_driftIC2Xdrift(p_kalman->p_X, p_kalman->p_best->mean, p_kalman->p_data);
FILE *p_file_X = (print_opt & PLOM_PRINT_X) ? plom_fopen(SFR_PATH, GENERAL_ID, "X", "w", header_X, p_kalman->p_data): NULL;
FILE *p_file_hat = (print_opt & PLOM_PRINT_HAT) ? plom_fopen(SFR_PATH, GENERAL_ID, "hat", "w", header_hat, p_kalman->p_data): NULL;
FILE *p_file_pred_res = (print_opt & PLOM_PRINT_PRED_RES) ? plom_fopen(SFR_PATH, GENERAL_ID, "pred_res", "w", header_prediction_residuals_ekf, p_kalman->p_data): NULL;
double log_like = run_kalman(p_kalman->p_X, p_kalman->p_best, p_kalman->p_par, p_kalman->p_kalman_update, p_kalman->p_data, p_kalman->calc, f_prediction_ode, 0, p_file_X, p_file_hat, p_file_pred_res, print_opt);
if (print_opt & PLOM_PRINT_X) {
plom_fclose(p_file_X);
}
if (print_opt & PLOM_PRINT_HAT) {
plom_fclose(p_file_hat);
}
if (print_opt & PLOM_PRINT_PRED_RES) {
plom_fclose(p_file_pred_res);
}
if (!(print_opt & PLOM_QUIET)) {
time_end = s_clock();
struct s_duration t_exec = time_exec(time_begin, time_end);
sprintf(str, "logV: %g", log_like);
print_log(str);
sprintf(str, "Done in:= %dd %dh %dm %gs", t_exec.d, t_exec.h, t_exec.m, t_exec.s);
print_log(str);
}
if (print_opt & PLOM_PRINT_BEST) {
FILE *p_file_trace = plom_fopen(SFR_PATH, GENERAL_ID, "trace", "w", header_trace, p_kalman->p_data);
print_trace(p_file_trace, 0, p_kalman->p_best, p_kalman->p_data, log_like);
plom_fclose(p_file_trace);
}
plom_print_done(theta, p_kalman->p_data, p_kalman->p_best, SFR_PATH, GENERAL_ID, print_opt);
if (!(print_opt & PLOM_QUIET)) {
print_log("clean up...");
}
json_decref(theta);
clean_kalman(p_kalman);
return 0;
}
AnimationList& AnimationLoader::load_json_from_file(const char* filename) {
return load_json(load_text_file_content(filename));
}
