Trisurf Monte Carlo simulator
Samo Penic
2016-02-24 487968538b6902a8c102531f5ee60db1c757c219
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
#include <general.h>
#include <restore.h>
#include <snapshot.h>
#include <zlib.h>
#include "vesicle.h"
#include "vertex.h"
ts_bool parseDump(char *dumpfname) {
    xmlDocPtr doc;
    xmlNodePtr cur;
    ts_vesicle *vesicle;
 
    doc = xmlParseFile(dumpfname);
    
    if (doc == NULL ) {
        fatal("Dump file could not be found or parsed. It is correct file?",1);
    }
    
    cur = xmlDocGetRootElement(doc);
    
    if (cur == NULL) {
        fatal("Dump file is empty.",1);
    }
    
    if (xmlStrcmp(cur->name, (const xmlChar *) "VTKFile")) {
        fatal("document of the wrong type, root node != story",1);
    }
    
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if ((!xmlStrcmp(cur->name, (const xmlChar *)"trisurf"))){
            vesicle=parseTrisurfTag(doc, cur);
        }
         
    cur = cur->next;
    }
    
    xmlFreeDoc(doc);
    fprintf(stderr,"Restoration completed\n");
    exit(0);
    vesicle_free(vesicle);
    return TS_SUCCESS;
}
 
ts_vesicle *parseTrisurfTag(xmlDocPtr doc, xmlNodePtr cur){
    fprintf(stderr,"Parsing trisurf tag\n");
    xmlNodePtr child;
 
#ifdef COMPRESS
    /* base64decode */
    size_t cLen;
    /*size_t tLen;
    const unsigned char test[]="Test";
    char *cTest=base64_encode(test, 4,&tLen);
    unsigned char *cuTest=base64_decode((char *)cTest,tLen,&tLen);
    cuTest[tLen]=0;
    fprintf(stderr,"%s\n",cuTest);
    */
    xmlChar *b64=xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
    unsigned char *compressed=base64_decode((char *)b64,strlen((char *)b64)-1,&cLen);
    /* uncompress */
    unsigned char *subtree=(unsigned char *)malloc(512000*sizeof(unsigned char)); /* TODO: again, the uncompressed string must not exceed this */
    z_stream infstream;
    infstream.zalloc = Z_NULL;
    infstream.zfree = Z_NULL;
    infstream.opaque = Z_NULL;
    infstream.avail_in = (ts_uint)cLen; // size of input
        infstream.next_in = compressed; // input char array
        infstream.avail_out = (ts_uint)512000; // size of output
        infstream.next_out = subtree; // output char array
     
        // the actual DE-compression work.
        inflateInit(&infstream);
        inflate(&infstream, Z_NO_FLUSH);
        inflateEnd(&infstream);    
    fprintf(stderr,"%lu\n",cLen);
    subtree[infstream.total_out]='\0'; //zero terminate string    
    fprintf(stderr,"%s\n",subtree);
    
    free(subtree);
#endif
    /*parse xml subtree */
    xmlChar *nvtx, *npoly, *nfono;
    nvtx = xmlGetProp(cur, (xmlChar *)"nvtx");
    npoly=xmlGetProp(cur, (xmlChar *)"npoly");
    nfono=xmlGetProp(cur, (xmlChar *)"nfono");
    fprintf(stderr,"nvtx=%u\n",atoi((char *)nvtx));
    ts_vesicle *vesicle=init_vesicle(atoi((char *)nvtx),10,10,10,0.1);
    //vesicle->poly_list=init_poly_list(atoi((char *)npoly),atoi((char *)nmono), vesicle->vlist, vesicle);
    xmlFree(nvtx);
    xmlFree(npoly);
    xmlFree(nfono);
 
    child = cur->xmlChildrenNode;
    while (child != NULL) {
        if ((!xmlStrcmp(child->name, (const xmlChar *)"vtxn"))){
            parseTrisurfVtxn(vesicle->vlist, doc, child);
        }
         
    child = child->next;
    }
 
 
 
    return vesicle;
}
 
ts_bool *parseTrisurfVtxn(ts_vertex_list *vlist, xmlDocPtr doc, xmlNodePtr cur){
 
    xmlChar *chari;
    xmlChar *neighs;
    char *n;
    char *token;
    ts_uint neighi;
    ts_uint i;
    chari = xmlGetProp(cur, (xmlChar *)"idx");
    i=atoi((char *)chari);
    xmlFree(chari);
    ts_vertex *vtx=vlist->vtx[i];
    neighs = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
    //fprintf(stderr,"Found neigh for vtx %u that seems to have index %u with neighs=%s\n",i,vtx->idx,neighs);
 
    n=(char *)neighs;
    token=strtok(n," ");
    while(token!=NULL){
        neighi=atoi(token);
        //fprintf(stderr,"%u", neighi);
        vtx_add_neighbour(vtx,vlist->vtx[neighi]);
        token=strtok(NULL," ");
    }    
    xmlFree(neighs);
    return TS_SUCCESS;
}