static int
test(char *buf, unsigned lineno)
{
char *last;
char *c;
uint32_t in[MAX_LENGTH_CANON];
size_t in_len;
uint32_t out[MAX_LENGTH_CANON];
size_t out_len;
uint32_t *tmp;
size_t norm_len;
int ret;
c = strtok_r(buf, ";", &last);
if (c == NULL)
return 0;
in_len = parse_vector(c, in);
if (strtok_r(NULL, ";", &last) == NULL)
return 0;
if (strtok_r(NULL, ";", &last) == NULL)
return 0;
c = strtok_r(NULL, ";", &last);
if (c == NULL)
return 0;
out_len = parse_vector(c, out);
if (strtok_r(NULL, ";", &last) == NULL)
return 0;
c = last;
norm_len = MAX_LENGTH_CANON;
tmp = malloc(norm_len * sizeof(uint32_t));
if (tmp == NULL && norm_len != 0)
err(1, "malloc");
ret = _wind_stringprep_normalize(in, in_len, tmp, &norm_len);
if (ret) {
printf("wind_stringprep_normalize %s failed\n", c);
free(tmp);
return 1;
}
if (out_len != norm_len) {
printf("%u: wrong out len (%s)\n", lineno, c);
dump_vector("Expected", out, out_len);
dump_vector("Received", tmp, norm_len);
free(tmp);
return 1;
}
if (memcmp(out, tmp, out_len * sizeof(uint32_t)) != 0) {
printf("%u: wrong out data (%s)\n", lineno, c);
dump_vector("Expected", out, out_len);
dump_vector("Received", tmp, norm_len);
free(tmp);
return 1;
}
free(tmp);
return 0;
}
static void do_state_sharp(char *ibuf, char **pscan)
{
if (**pscan == 'd'){
//only deal with decimal
current_state = STATE_NUM;
++*pscan;
} else if (**pscan == '\\'){
current_state = STATE_CHAR;
++*pscan;
} else if (**pscan == '('){
parse_vector(ibuf, pscan);
} else if (**pscan == 't' || **pscan == 'f'){
boolean b = (**pscan == 't') ? true : false;
++*pscan;
if (is_delimiter(**pscan) || **pscan == '\0'){
stack_push(&parser_stack, make_boolean(b));
current_state = stack_pop(&state_stack);
}else {
printf("Error: illegally uses '#' -- READ\n");
do_input_error(pscan);
}
} else{
printf("Error: illegally uses '#' -- READ\n");
do_input_error(pscan);
}
}
Poly* parse_poly(char* buffer)
{
char* cvec;
Poly* poly = new Poly();
cvec = strtok(buffer, ";");
while (cvec!=NULL)
{
poly->addVertex(parse_vector(cvec));
cvec = strtok(NULL, ";");
}
return poly;
}
//parser
cellpoint read_parse(char *ibuf, char **pscan)
{
current_state = STATE_INIT;
stack_init(&parser_stack);
stack_init(&state_stack);
while (*pscan == NULL || **pscan == '\0'){
*pscan = reload_ibuffer(ibuf);
}
while (1){
if (current_state == STATE_INIT && !stack_is_empty(&parser_stack)){
//parses a object
return stack_pop(&parser_stack);
}
if (current_state == STATE_INIT){
do_state_init(ibuf, pscan);
}else if (current_state == STATE_SHARP){
do_state_sharp(ibuf, pscan);
}else if (current_state == STATE_DOT){
do_state_dot(pscan);
}else if (current_state == STATE_ADD){
do_state_add(pscan);
}else if (current_state == STATE_SUB){
do_state_sub(pscan);
}else if (current_state == STATE_NUM){
//parses number object
parse_num(pscan);
}else if (current_state == STATE_CHAR){
//parses character object
parse_char(pscan);
}else if (current_state == STATE_STR){
//parses string object
parse_string(ibuf, pscan);
}else if (current_state == STATE_SYM){
//parses symbol object
parse_sym(pscan);
}else if (current_state == STATE_LIST){
//parses list object
parse_list(ibuf, pscan);
}else if (current_state == STATE_VEC){
//parses vector object
parse_vector(ibuf, pscan);
}else {
perror("Error: Bad state. -- READ\n");
error_handler();
return NIL;
}
}
}
static void do_state_init(char *ibuf, char **pscan)
{
if (**pscan == '#'){
stack_push(&state_stack, current_state);
current_state = STATE_SHARP;
++*pscan;
} else if (**pscan == '\''){
stack_push(&state_stack, current_state);
current_state = STATE_QUOTE;
++*pscan;
do_state_init(ibuf, pscan);
}else if (**pscan == '.'){
stack_push(&state_stack, current_state);
current_state = STATE_DOT;
++*pscan;
} else if (**pscan == '+'){
stack_push(&state_stack, current_state);
current_state = STATE_ADD;
++*pscan;
} else if (**pscan == '-'){
stack_push(&state_stack, current_state);
current_state = STATE_SUB;
++*pscan;
} else if (is_digit(**pscan)){
stack_push(&state_stack, current_state);
current_state = STATE_NUM;
} else if (is_initial(**pscan)){
stack_push(&state_stack, current_state);
current_state = STATE_SYM;
} else if (**pscan == '"'){
stack_push(&state_stack, current_state);
current_state = STATE_STR;
++*pscan;
} else if (**pscan == '('){
parse_list(ibuf, pscan);
} else if (**pscan == ')'){
if (current_state == STATE_LIST){
parse_list(ibuf, pscan);
}else if (current_state == STATE_VEC){
parse_vector(ibuf, pscan);
}else {
printf("Error: unexpected ')' -- READ\n");
do_input_error(pscan);
}
} else if(is_atmosphere(**pscan)){
eat_atmosphere(pscan);
} else{
perror("Error: Bad input. -- READ\n");
do_input_error(pscan);
}
}
VeDeviceElement *veDeviceParseElem(char *spec) {
VeDeviceElement *e;
VeDeviceEContent *content;
char *s, *dup, *name, *type, *ptr;
dup = veDupString(spec); /* save spec - may not be alterable... */
ptr = dup;
name = veNextLElem(&ptr);
if (name && strcmp(name,"elem") == 0)
name = veNextLElem(&ptr); /* skip leading "elem" if there */
if (!name) {
veError(MODULE,"veDeviceParseElem: missing name in spec: %s", spec);
veFree(dup);
return NULL;
}
if (!(type = veNextLElem(&ptr))) {
veError(MODULE,"veDeviceParseElem: missing type in spec: %s", spec);
veFree(dup);
return NULL; /* type */
}
/* parse content based upon name */
content = NULL;
s = ptr ? ptr : "";
if (strcmp(type,"trigger") == 0)
content = parse_trigger(s);
else if (strcmp(type,"switch") == 0)
content = parse_switch(s);
else if (strcmp(type,"valuator") == 0)
content = parse_valuator(s);
else if (strcmp(type,"vector") == 0)
content = parse_vector(s);
else if (strcmp(type,"keyboard") == 0)
content = parse_keyboard(s);
else
veError(MODULE,"veDeviceParseElem: unknown elem type %s in spec: %s",
type, spec);
if (!content) {
veFree(dup);
return NULL; /* parsing of content failed - don't continue */
}
e = veAllocObj(VeDeviceElement);
e->name = veDupString(name);
e->content = content;
return e;
}
int LatentRelevance::parse_line(char* buf, data_t* data)
{
// Parse label
char* ptr = strtok(buf, "\t");
if(ptr == NULL) {
printf("[WARNING] Parsing label failed!\n");
return -1;
}
data->y = static_cast<int>(strtol(ptr, NULL, 10));
if (data->y != 1 && data->y != -1 && data->y != 0) {
printf("[WARNING] Invalid label (should be 1(positive) or -1/0(negative))!\n");
return -1;
}
// Parse x1
char* x1 = strtok(NULL, "\t");
if (x1 == NULL) {
printf("[WARNING] Parsing x1 failed!\n");
return -1;
}
// Parse x2
char* x2 = strtok(NULL, "\t");
if (x2 == NULL) {
printf("[WARNING] Parsing x2 failed!\n");
return -1;
}
// Get vector_size when parsing the 1st line
if (vector_size == 0) {
int x1_size = count_char_number(x1, ' ');
int x2_size = count_char_number(x2, ' ');
if (x1_size != x2_size or x1_size < 1) {
printf("[WARNING] Invalid vector x1 and x2!\n");
return -1;
}
else {
vector_size = x1_size + 1;
}
}
else {
int x1_size = count_char_number(x1, ' ');
if (vector_size != x1_size + 1) {
printf("[WARNING] Wrong data vector size!");
return -1;
}
}
// Allocate data memory
data->x = new float[2 * vector_size];
if (factorize_mode == 0) {
data->x_ij = new float[vector_size * vector_size];
}
// Parse x1 elements
if (parse_vector(x1, data->x) != vector_size) {
printf("[WARNING] Parsing x1 failed!\n");
delete data->x;
data->x = NULL;
if (factorize_mode == 0 && data->x_ij != NULL) {
delete data->x_ij;
data->x_ij = NULL;
}
return -1;
}
// Parse x2 elements
if (parse_vector(x2, data->x + vector_size) != vector_size) {
printf("[WARNING] Parsing x2 failed!\n");
delete data->x;
data->x = NULL;
if (factorize_mode == 0 && data->x_ij != NULL) {
delete data->x_ij;
data->x_ij = NULL;
}
return -1;
}
return 0;
}
/** Parses the ICCP3M command.
*/
int iccp3m(ClientData data, Tcl_Interp *interp, int argc, char **argv) {
int last_ind_id,num_iteration,normal_args,area_args;
char buffer[TCL_DOUBLE_SPACE];
double e1,convergence,relax;
Tcl_AppendResult(interp, "The ICCP3M algorithm is still experimental. Function can not be guaranteed, therefore it is still disabled.\n", (char *)NULL);
return (TCL_ERROR);
if(iccp3m_initialized==0){
iccp3m_init();
iccp3m_initialized=1;
}
if(argc != 9 && argc != 2 && argc != 10) {
Tcl_AppendResult(interp, "Wrong # of args! Usage: iccp3m { iterate | <last_ind_id> <e1> <num_iteration> <convergence> <relaxation> <area> <normal_components> <e_in/e_out> [<ext_field>] }", (char *)NULL);
return (TCL_ERROR);
}
if (argc == 2 ){
if(ARG_IS_S(1,"iterate")) {
if (iccp3m_cfg.set_flag==0) {
Tcl_AppendResult(interp, "iccp3m parameters not set!", (char *)NULL);
return (TCL_ERROR);
}
else{
Tcl_PrintDouble(interp,mpi_iccp3m_iteration(0),buffer);
Tcl_AppendResult(interp, buffer, (char *) NULL);
return TCL_OK;
}
}
}
else {
if(!ARG_IS_I(1, last_ind_id)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Last induced id must be integer (got: ", argv[1],")!", (char *)NULL); return (TCL_ERROR);
} else if(last_ind_id < 2) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Last induced id can not be smaller then 2 (got: ", argv[1],")!", (char *)NULL); return (TCL_ERROR);
}
if(!ARG_IS_D(2, e1)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Dielectric constant e1(inner) must be double(got: ", argv[2],")!", (char *)NULL); return (TCL_ERROR);
}
if(!ARG_IS_I(3, num_iteration)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Number of maximum iterations must be integer (got: ", argv[4],")!", (char *)NULL); return (TCL_ERROR);
}
if(!ARG_IS_D(4, convergence)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Convergence criterion must be double (got: ", argv[5],")!", (char *)NULL); return (TCL_ERROR);
} else if( (convergence < 1e-10) || (convergence > 1e-1) ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Convergence criterion can not be smaller then 1e-10 and greater then 1e-2(got: ", argv[5],")!", (char *)NULL); return (TCL_ERROR);
}
if(!ARG_IS_D(5, relax)) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "Relaxation parameter must be double (got: ", argv[6],")!", (char *)NULL); return (TCL_ERROR);
}
iccp3m_cfg.last_ind_id = last_ind_id; /* Assign needed options */
iccp3m_cfg.num_iteration = num_iteration; /* maximum number of iterations to go */
iccp3m_cfg.eout = e1;
iccp3m_cfg.convergence = convergence;
iccp3m_cfg.relax = relax;
iccp3m_cfg.update = 0;
iccp3m_cfg.set_flag = 1;
normal_args = (iccp3m_cfg.last_ind_id+1)*3;
/* Now get Normal Vectors components consecutively */
if( parse_vector(interp,normal_args,argv[7],ICCP3M_NORMAL) == 1) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "ICCP3M: Error in following normal vectors\n", argv[7],"\nICCP3M: Error in previous normal vectors\n", (char *)NULL);
return (TCL_ERROR);
}
area_args=(iccp3m_cfg.last_ind_id+1);
/* Now get area of the boundary elements */
if ( parse_vector(interp,area_args,argv[6],ICCP3M_AREA) == 1 ){
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "ICCP3M: Error in following areas\n", argv[6],"\nICCP3M: Error in previous areas\n", (char *)NULL); return (TCL_ERROR);
}
/* Now get the ration ein/eout for each element.
It's the user's duty to make sure that only disconnected
regions have different ratios */
if ( parse_vector(interp,area_args,argv[8],ICCP3M_EPSILON) == 1 ) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "ICCP3M: Error in following dielectric constants\n", argv[8],"\nICCP3M: Error in previous dielectric constants\n", (char *)NULL); return (TCL_ERROR);
}
if( argc == 10 ) {
if( parse_vector(interp,normal_args,argv[9],ICCP3M_EXTFIELD) == 1) {
Tcl_ResetResult(interp);
Tcl_AppendResult(interp, "ICCP3M: Error in following external field vectors\n", argv[9],"\nICCP3M: Error in previous external field vectors\n", (char *)NULL); return (TCL_ERROR);
}
}
else {
printf("allocating zeroes for external field \n");
iccp3m_cfg.extx = (double*)calloc((last_ind_id +1), sizeof(double));
iccp3m_cfg.exty = (double*)calloc((last_ind_id +1), sizeof(double));
iccp3m_cfg.extz = (double*)calloc((last_ind_id +1), sizeof(double));
}
mpi_iccp3m_init(0);
Tcl_PrintDouble(interp,mpi_iccp3m_iteration(0),buffer);
Tcl_AppendResult(interp, buffer, (char *) NULL);
return TCL_OK;
} /* else (argc==10) */
return TCL_OK;
}
static int obj_Cgmap(ClientData /*UNUSED*/, Tcl_Interp *interp, int argc, Tcl_Obj * const objv[])
{
Tcl_Obj *atomselect = NULL;
Tcl_Obj *object = NULL;
Tcl_Obj *bytes = NULL;
Tcl_Obj *bytes_append = NULL;
Tcl_Obj *sel = NULL;
float *coords = NULL;
float *coords_append = NULL;
const char *blockid_field = "user";
const char *order_field = "user2";
const char *weight_field= "user3";
int nframes, natoms, ncoords, result, length;
int first, last, stride;
int molid, append_molid;
natoms = ncoords = result = 0;
molid = append_molid = 0;
first = last = 0;
stride = 1;
nframes = 1;
std::vector<float> weight;
std::vector<int> bead;
std::vector<int> index;
// Parse Arguments
int n = 1;
while (n < argc) {
const char *cmd = Tcl_GetString(objv[n]);
if (!strncmp(cmd, "-molid", 7)) {
if (Tcl_GetIntFromObj(interp,objv[n+1], &molid) != TCL_OK) {return TCL_ERROR;}
n += 2;
} else if (!strncmp(cmd, "-append", 8)) {
if (Tcl_GetIntFromObj(interp,objv[n+1], &append_molid) != TCL_OK) {return TCL_ERROR;}
n += 2;
} else if (!strncmp(cmd, "-sel", 5)) {
sel = objv[n+1];
n += 2;
} else if (!strncmp(cmd, "-first", 5)) {
if (Tcl_GetIntFromObj(interp,objv[n+1], &first) != TCL_OK) {return TCL_ERROR;}
n += 2;
} else if (!strncmp(cmd, "-last", 4)) {
if (Tcl_GetIntFromObj(interp,objv[n+1], &last) != TCL_OK) {return TCL_ERROR;}
n += 2;
} else if (!strncmp(cmd, "-stride", 6)) {
if (Tcl_GetIntFromObj(interp,objv[n+1], &stride) != TCL_OK) {return TCL_ERROR;}
n += 2;
} else if (!strncmp(cmd, "-weight", 7)) {
weight_field = Tcl_GetString(objv[n+1]);
n += 2;
} else if (!strncmp(cmd, "-blockid", 7)) {
blockid_field = Tcl_GetString(objv[n+1]);
n += 2;
} else if (!strncmp(cmd, "-order", 6)) {
order_field = Tcl_GetString(objv[n+1]);
n += 2;
} else {
Tcl_WrongNumArgs(interp,1,objv, (char *)"molid");
return TCL_ERROR;
}
}
// Create an internal selection that we can manipulate if none was defined
// Note that a passed selection overides the passed molid
if (!sel) {
Tcl_Obj *script = Tcl_ObjPrintf("atomselect %i all", molid);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect", TCL_STATIC);
return TCL_ERROR;
}
atomselect = Tcl_GetObjResult(interp);
Tcl_IncrRefCount(atomselect);
} else {
// Create a internal selection that is a COPY of the passed selection
atomselect = Tcl_DuplicateObj(sel);
Tcl_IncrRefCount(atomselect);
// Get the molid
Tcl_Obj *script = Tcl_DuplicateObj(sel);
Tcl_AppendToObj(script, " molid", -1);
if(Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect", TCL_STATIC);
return TCL_ERROR;
}
Tcl_Obj *molid_result = Tcl_GetObjResult(interp);
if (Tcl_GetIntFromObj(interp, molid_result, &molid) != TCL_OK) {return TCL_ERROR;}
}
// Get the number of frames
Tcl_Obj *script = Tcl_ObjPrintf("molinfo %i get numframes", molid);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling molinfo for nframes", TCL_STATIC);
return TCL_ERROR;
}
object = Tcl_GetObjResult(interp);
if (Tcl_GetIntFromObj(interp, object, &nframes) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing number of frames", TCL_STATIC);
return TCL_ERROR;
}
if ( first < 0 || first >= nframes ) {
Tcl_SetResult(interp, (char *) "Cgmap: illegal value of first_frame", TCL_STATIC);
return TCL_ERROR;
}
if ( last == -1 || last > nframes || last < first ) last = nframes;
// Get the number of atoms from selection
script = Tcl_DuplicateObj(atomselect);
Tcl_AppendToObj(script, " num", -1);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect", TCL_STATIC);
return TCL_ERROR;
}
object = Tcl_GetObjResult(interp);
if (Tcl_GetIntFromObj(interp, object, &natoms) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing number of atoms", TCL_STATIC);
return TCL_ERROR;
}
// Make sure we actually have some atoms
if (natoms == 0) {
Tcl_SetResult(interp, (char *) "Cgmap: Selection or molecule contains no atoms", TCL_STATIC);
return TCL_ERROR;
}
// Get the weights (mass)
script = Tcl_DuplicateObj(atomselect);
Tcl_AppendPrintfToObj (script, " get %s", weight_field);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect for weights", TCL_STATIC);
return TCL_ERROR;
}
ncoords = parse_vector(Tcl_GetObjResult(interp), weight, interp);
if (ncoords == -1) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing atomselect result", TCL_STATIC);
return TCL_ERROR;
}
// Get the bead IDs
script = Tcl_DuplicateObj(atomselect);
Tcl_AppendPrintfToObj (script, " get %s", blockid_field);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect for blocks", TCL_STATIC);
return TCL_ERROR;
}
ncoords = parse_ivector(Tcl_GetObjResult(interp), bead, interp, true);
if (ncoords == -1) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing atomselect result", TCL_STATIC);
return TCL_ERROR;
}
// Get the atom IDs, we use these as a map when accessing the coordinate array
// user2 is set via ::CGit::setBeadID
script = Tcl_DuplicateObj(atomselect);
Tcl_AppendPrintfToObj (script, " get %s", order_field);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error calling atomselect for order", TCL_STATIC);
return TCL_ERROR;
}
ncoords = parse_ivector(Tcl_GetObjResult(interp), index, interp, true);
if (ncoords == -1) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing atomselect result", TCL_STATIC);
return TCL_ERROR;
}
// Get current frame of the target mol
script = Tcl_ObjPrintf("molinfo %d get frame", append_molid);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error getting append mol's current frame", TCL_STATIC);
return TCL_ERROR;
}
int append_frame = 0;
object = Tcl_GetObjResult(interp);
if (Tcl_GetIntFromObj(interp, object, &append_frame) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing append mol's current frame", TCL_STATIC);
return TCL_ERROR;
}
//Get number of atoms in target (append) mol
script = Tcl_ObjPrintf("molinfo %i get numatoms", append_molid);
if (Tcl_EvalObjEx(interp, script, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error getting append mol's number of atoms", TCL_STATIC);
return TCL_ERROR;
}
int append_natoms = 0;
object = Tcl_GetObjResult(interp);
if (Tcl_GetIntFromObj(interp, object, &append_natoms) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error parsing append mol's number of atoms", TCL_STATIC);
return TCL_ERROR;
}
int print = ((last - first) / 10);
if (print < 10) print = 10;
if (print > 100) print = 100;
//Loop over frames, calculate COMS, set coordinates in target mol
for (int frame = first;
frame <= last && frame < nframes;
frame += stride) {
if (frame % print == 0) {
//Tcl_Obj *msg = Tcl_ObjPrintf ("puts \"Mapping frame %i\"", frame);
Tcl_Obj *msg = Tcl_ObjPrintf ("vmdcon -info \"CGit> Mapping frame %i\"", frame);
result = Tcl_EvalObjEx(interp, msg, TCL_EVAL_DIRECT);
if (result != TCL_OK) { return TCL_ERROR; }
}
//Update the frames
Tcl_Obj *mol_chgframe = Tcl_ObjPrintf ("molinfo top set frame %i", frame);
if (Tcl_EvalObjEx(interp, mol_chgframe, TCL_EVAL_DIRECT) != TCL_OK)
return TCL_ERROR;
// Get the coordinates of the molecules in the reference mol
Tcl_Obj *get_ts = Tcl_ObjPrintf("gettimestep %d %i", molid, frame);
if (Tcl_EvalObjEx(interp, get_ts, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error getting coordinates", TCL_STATIC);
return TCL_ERROR;
}
bytes = Tcl_GetObjResult(interp);
Tcl_IncrRefCount(bytes);
Tcl_InvalidateStringRep (bytes);
coords = reinterpret_cast<float *> (Tcl_GetByteArrayFromObj(bytes, &length));
/** Create a new frame for append_mol **/
Tcl_ObjPrintf("animate dup %i", append_molid);
if (Tcl_EvalObjEx(interp, get_ts, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error adding frame to append mol", TCL_STATIC);
return TCL_ERROR;
}
append_frame++;
Tcl_Obj *setframe = Tcl_ObjPrintf("molinfo %i set frame %i; display update", molid, frame);
if (Tcl_EvalObjEx(interp, setframe, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error updating source frame", TCL_STATIC);
return TCL_ERROR;
}
// Copy PBC conditions
Tcl_Obj *setpbc = Tcl_ObjPrintf("molinfo %i set {a b c} [molinfo %i get {a b c}]", append_molid, molid);
if (Tcl_EvalObjEx(interp, setpbc, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error updating PBC", TCL_STATIC);
return TCL_ERROR;
}
// Get the coordinates of the molecules in the target (append) mol
get_ts = Tcl_ObjPrintf("gettimestep %d %i", append_molid, append_frame);
if (Tcl_EvalObjEx(interp, get_ts, TCL_EVAL_DIRECT) != TCL_OK) {
Tcl_SetResult(interp, (char *) "Cgmap: error getting coordinates", TCL_STATIC);
return TCL_ERROR;
}
bytes_append = Tcl_GetObjResult(interp);
Tcl_IncrRefCount(bytes_append);
Tcl_InvalidateStringRep(bytes_append);
coords_append = reinterpret_cast<float *> (Tcl_GetByteArrayFromObj(bytes_append, &length));
//loop over coordinates and beads, calculate COMs
int current_bead, current_atom;
current_bead = current_atom = 0;
// Nested loop to work on each bead at a time
float w,x,y,z;
int j = 0;
for (int start_atom = 0; start_atom < natoms; ) {
current_bead = bead[start_atom];
w = x = y = z = 0;
// Calculate COM for each bead
for ( current_atom = start_atom;
current_atom < natoms && bead[current_atom] == current_bead;
current_atom++) {
//Lookup the atom index from the selection
unsigned int idx = index[current_atom];
float tw = weight[current_atom];
w += tw;
x += tw * coords[3*idx];
y += tw * coords[3*idx+1];
z += tw * coords[3*idx+2];
}
if (w == 0) {
Tcl_SetResult(interp, (char *) "Cgmap: Bad weight can't total zero", TCL_STATIC);
return TCL_ERROR;
}
// Insert calculated COMS into append_mols coordinate array
// Need to figure out some kind of bounds checking here...
coords_append[3 * j ] = x / w;
coords_append[3 * j + 1] = y / w;
coords_append[3 * j + 2] = z / w;
start_atom = current_atom;
j++;
} // bead loop
// call rawtimestep to set byte array for append_mol
Tcl_Obj *set_ts[5];
set_ts[0] = Tcl_NewStringObj("rawtimestep", -1);
set_ts[1] = Tcl_ObjPrintf("%d",append_molid);
set_ts[2] = bytes_append;
set_ts[3] = Tcl_NewStringObj("-frame", -1);
set_ts[4] = Tcl_NewIntObj(append_frame);
if (Tcl_EvalObjv (interp, 5, set_ts, 0) != TCL_OK)
return TCL_ERROR;
//Cleanup
Tcl_DecrRefCount(bytes);
Tcl_DecrRefCount(bytes_append);
} // Frame loop
//Cleanup
Tcl_DecrRefCount(atomselect);
Tcl_SetResult(interp, (char *) "", TCL_STATIC);
return TCL_OK;
}
/**
* Parses the byte stream according to the given document type
* and creates a document model from it.
*
* @param p0 the destination (Hand over as reference!)
* @param p1 the destination count
* @param p2 the destination size
* @param p3 the source
* @param p4 the source count
* @param p5 the type
* @param p6 the type count
*/
void parse(void* p0, void* p1, void* p2, const void* p3, const void* p4,
const void* p5, const void* p6) {
// The comparison result.
int r = 0;
if (r != 1) {
compare_arrays(p5, p6, (void*) CYBOL_ABSTRACTION, (void*) CYBOL_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_xml(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) OPERATION_ABSTRACTION, (void*) OPERATION_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_string(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) STRING_ABSTRACTION, (void*) STRING_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_string(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) BOOLEAN_ABSTRACTION, (void*) BOOLEAN_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_boolean(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) INTEGER_ABSTRACTION, (void*) INTEGER_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_integer(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) VECTOR_ABSTRACTION, (void*) VECTOR_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_vector(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) DOUBLE_ABSTRACTION, (void*) DOUBLE_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_double(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) FRACTION_ABSTRACTION, (void*) FRACTION_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_fraction(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) COMPLEX_ABSTRACTION, (void*) COMPLEX_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_complex(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) TIME_ABSTRACTION, (void*) TIME_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_time(p0, p1, p2, p3, p4);
}
}
if (r != 1) {
compare_arrays(p5, p6, (void*) CONFIGURATION_ABSTRACTION, (void*) CONFIGURATION_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
parse_xml(p0, p1, p2, p3, p4);
}
}
/*??
//?? Later, distinguish file types according to abstraction,
//?? for example xml, html, sxi, txt, rtf,
//?? adl (from OpenEHR), KIF, ODL etc.!
//?? For now, only the cybol file format is considered.
if (r != 1) {
compare_arrays(p5, p6, (void*) SXW_ABSTRACTION, (void*) SXW_ABSTRACTION_COUNT, (void*) &r, (void*) CHARACTER_ARRAY);
if (r == 1) {
//?? For other kinds of file (stream) formats,
//?? for example from special applications like Open Office,
//?? use a similar handling like for compound above!
//?? Images possibly also have to be handled that way.
//?? At first, the single image parameters have to be parsed
//?? and written into a special parameter model in memory;
//?? then that model has to be decoded into a knowledge model!
//?? May be this idea is rubbish and will not work!
//?? For the beginning, better handle images as primitve types.
}
}
*/
}
