source: sassie2/bin/bayesian_ensemble_estimator @ 1502

Last change on this file since 1502 was 1502, checked in by curtisj, 2 years ago

working progress bar: bayes

File size: 11.9 KB
Line 
1#!/share/apps/local/anaconda/bin/python
2import json
3import sys
4import os
5import shutil
6import time
7import math
8import locale
9import string
10from StringIO import StringIO
11import multiprocessing
12import time
13import string
14import socket
15
16import sassie.interface.input_filter as input_filter
17import sassie.analyze.bayesian_ensemble_estimator.bayesian_ensemble_estimator as bayesian_ensemble_estimator
18
19from mpi4py import MPI
20
21
22class Bayesian_Ensemble_Fit_Drv():
23
24    module = 'bayesian_ensemble_estimator'
25
26    def message_box(self, text, icon):
27
28        _message = {}
29        _message['icon'] = icon
30        _message['text'] = text
31
32        UDP_IP = json_variables['_udphost']
33        UDP_PORT = json_variables['_udpport']
34        sock = socket.socket(socket.AF_INET,  # Internet
35                             socket.SOCK_DGRAM)  # UDP
36
37        socket_dict = {}
38        socket_dict['_uuid'] = json_variables['_uuid']
39        socket_dict['_message'] = _message
40
41        doc_string = json.dumps(socket_dict)
42        sock.sendto(doc_string, (UDP_IP, UDP_PORT))
43
44        return
45
46    def background_job(self, process, txtQueue, json_variables):
47
48        total_string = ''
49
50        UDP_IP = json_variables['_udphost']
51        UDP_PORT = json_variables['_udpport']
52        sock = socket.socket(socket.AF_INET,  # Internet
53                        socket.SOCK_DGRAM)  # UDP
54
55        socket_dict = {}
56        socket_dict['_uuid'] = json_variables['_uuid']
57        first = True
58
59        runname = json_variables['runname']
60        base_directory = json_variables['_base_directory']
61        status_data_file_name = os.path.join(
62                base_directory, runname, self.module, '._status.txt')
63
64        alive = True
65        while process.is_alive():
66                #try:
67                if alive:
68       
69                        if not process.is_alive():
70                                alive = False
71
72                        if(first):
73                                socket_dict['progress_html'] = 0.01
74                                socket_dict['_progress'] = 0.01
75                                socket_dict['progress_html'] = '<center>starting job</center>'
76                                doc_string = json.dumps(socket_dict)
77                                sock.sendto(doc_string, (UDP_IP, UDP_PORT))
78                                first = False
79
80
81                        try:
82                        #if True:
83
84                                try:
85                                        status_data_file = open(status_data_file_name,'r').readlines()
86                                        if status_data_file:
87                                                text_split = string.split(status_data_file[0])
88
89                                except:
90                                        status_data_file = False
91
92                                try:
93                                        this_text = txtQueue.get(True, timeout=0.1)
94                                        text_split = string.split(this_text)
95                                except:
96                                        this_text = ''
97
98                                if(text_split[0] == 'STATUS'):
99                                        #print '### STATUS = ' + text_split[1]
100                                        value = locale.atof(text_split[1])
101                                        svalue = str(round(100 * value, 2))
102                                        socket_dict['progress_output'] = value
103                                        socket_dict['_progress'] = value
104                                        socket_dict['progress_html'] = '<center>' + \
105                                                svalue + '</center>'
106       
107                                        if "_textarea" in socket_dict:
108                                                del socket_dict["_textarea"]
109       
110                                        if socket_dict:
111                                                doc_string = json.dumps(socket_dict)
112                                                sock.sendto(doc_string, (UDP_IP, UDP_PORT))
113                                else:
114                                        socket_dict["_textarea"] = this_text
115                                        if socket_dict:
116                                                doc_string = json.dumps(socket_dict)
117                                                sock.sendto(doc_string, (UDP_IP, UDP_PORT))
118                                        total_string += this_text
119                        except:
120                        #else:
121                #except:
122                                time.sleep(0.01)
123
124                else:
125                        if not process.is_alive():
126                                time.sleep(0.01)
127                                return total_string
128                        else:
129                                return total_string
130
131        return total_string
132
133    def run_me(self, json_flag, json_variables, input_string):
134
135        output_dict = {}
136
137        folder_flag = True
138
139        if not json_flag:
140
141            # BEGIN USER EDIT
142            # BEGIN USER EDIT
143            # BEGIN USER EDIT
144
145            runname = 'run_0'
146            sas_data = 'input_and_testing_files/saxs.dat'
147            d_max = '83.6'
148            theoretical_profiles_zip = 'input_and_testing_files/TheoryFiles.zip'
149            max_iterations = '10'
150            posterior_burn = '0'
151            number_of_MCs = '3'
152            nproc = 4
153
154            # Advanced Input
155            auxiliary_data = ''
156            use_all = 'False'
157            every = 'False'
158            shansamp = 'True'
159            use_bic = 'True'
160            walk_one = 'False'
161            sigma = '0.10'
162            zeroing_threshold = '0.00'
163
164            path = './'
165
166            data_path = path
167            # END USER EDIT
168            # END USER EDIT
169            # END USER EDIT
170        else:
171            runname = json_variables['runname']
172
173            base_directory = json_variables['_base_directory']
174
175            path = base_directory.replace('\/', '/') + "/"
176
177            os.chdir(path)
178
179            sas_data = json_variables['sas_data'][0]
180            theoretical_profiles_zip = json_variables[
181                'theoretical_profiles_zip'][0]
182
183            posterior_burn = json_variables['posterior_burn']
184            max_iterations = json_variables['max_iterations']
185            number_of_MCs = json_variables['number_of_MCs']
186            nproc = json_variables['nproc']
187            d_max = json_variables['d_max']
188
189            advanced_input = 'off'
190            use_all = 'False'
191            every = 'False'
192            shansamp = 'True'
193            use_bic = 'True'
194            walk_one = 'False'
195            sigma = '0.10'
196            auxiliary_data = ''
197            zeroing_threshold = '0.00'
198            use_auxiliary_data_checkbox = "off"
199            use_shansamp_checkbox = 'on'
200            use_bic_checkbox = 'on'
201            every_checkbox = 'off'
202            use_all_checkbox = 'off'
203            walk_one_checkbox = 'off'
204
205            try:
206                advanced_input = json_variables['advanced_input']
207            except:
208                pass
209
210            if(advanced_input == "on"):
211
212                try:
213                    use_auxiliary_data_checkbox = json_variables[
214                        'use_auxiliary_data_checkbox']
215                    auxiliary_data = json_variables['auxiliary_data']
216                except:
217                    use_auxiliary_data_checkbox = "off"
218                    auxiliary_data = ''
219
220                try:
221                    use_shansamp_checkbox = json_variables[
222                        'use_shansamp_checkbox']
223                except:
224                    use_shansamp_checkbox = "off"
225
226                try:
227                    use_bic_checkbox = json_variables['use_bic_checkbox']
228                except:
229                    use_bic_checkbox = "off"
230
231                try:
232                    every_checkbox = json_variables['every_checkbox']
233                except:
234                    every_checkbox = 'off'
235
236                try:
237                    use_all_checkbox = json_variables['use_all_checkbox']
238                except:
239                    use_all_checkbox = 'off'
240
241                try:
242                    walk_one_checkbox = json_variables['walk_one_checkbox']
243                except:
244                    walk_one_checkbox = 'off'
245
246                try:
247                    sigma = json_variables['sigma']
248                except:
249                    sigma = '0.10'
250
251                try:
252                    zeroing_threshold = json_variables['zeroing_threshold']
253                except:
254                    zeroing_threshold = '0.00'
255
256            if use_all_checkbox == "on":
257                use_all = 'True'
258            if use_bic_checkbox == "off":
259                use_bic = 'False'
260            if every_checkbox == "on":
261                every = 'True'
262            if walk_one_checkbox == "on":
263                walk_one = 'True'
264            if use_shansamp_checkbox == "off":
265                shansamp = 'False'
266
267        path = ''
268
269        # io = json_variables['io']
270        io = "1.0"  # hardwired for now
271
272        path = ''
273
274        svariables = {}
275
276        plotflag = '0'
277
278        svariables['runname'] = (str(runname), 'string')
279
280        svariables['sas_data'] = (sas_data, 'string')
281        svariables['theoretical_profiles_zip'] = (
282            theoretical_profiles_zip, 'string')
283        svariables['posterior_burn'] = (posterior_burn, 'int')
284        svariables['max_iterations'] = (max_iterations, 'int')
285        svariables['number_of_MCs'] = (number_of_MCs, 'int')
286        svariables['nproc'] = (str(nproc), 'int')
287        svariables['d_max'] = (d_max, 'float')
288
289        svariables['auxiliary_data'] = (auxiliary_data, 'string')
290        svariables['use_all'] = (use_all, 'boolean')
291        svariables['use_bic'] = (use_bic, 'boolean')
292        svariables['every'] = (every, 'boolean')
293        svariables['shansamp'] = (shansamp, 'boolean')
294        svariables['walk_one'] = (walk_one, 'boolean')
295        svariables['sigma'] = (sigma, 'float')
296        svariables['zeroing_threshold'] = (zeroing_threshold, 'float')
297
298#        print 'svariables: ',svariables
299        error, self.variables = input_filter.type_check_and_convert(svariables)
300#        print 'variables: ', self.variables
301#        print 'error: ', error
302
303        if(len(error) > 0):
304
305            self.message_box(error, 'skull.png')
306
307#           warning.png, information.png, skull.png, toast.png
308
309            output_dict['error'] = 'Error in input variables'
310            output_dict['sasoutput2'] = 'run failed'
311            print json.dumps(output_dict)
312            return
313        else:
314            #            error=chi_square_filter_filter.check_chi_square_filter(self.variables,no_file_check="true")
315            #            print 'error after filter check: ', error
316            #            print 'variables after filter check: ', self.variables
317
318            if(len(error) != 0):
319                self.message_box(error, 'warning.png')
320
321                output_dict[
322                    'error'] = 'Error in bayesian ensemble fit variables'
323                output_dict['sasoutput2'] = 'run failed'
324                output_dict['sasoutput2'] = error
325                print json.dumps(output_dict)
326                return
327
328            runname = self.variables['runname'][0]
329
330            if (os.path.exists(runname + '/' + self.module) and folder_flag):
331                shutil.rmtree(runname + '/' + self.module)
332
333            txtQueue = multiprocessing.JoinableQueue()
334            plotQueue = multiprocessing.JoinableQueue()
335
336            reweighting = bayesian_ensemble_estimator.ensemble_routine()
337
338            process = multiprocessing.Process(
339                target=reweighting.main, args=(self.variables, txtQueue,
340                                               plotQueue))
341            process.start()
342
343            if json_flag:
344                total_string = self.background_job(
345                    process, txtQueue, json_variables)
346            else:
347                json_variables = {}
348                json_variables['_udphost'] = "localhost"
349                json_variables['_udpport'] = "10001"
350                json_variables['_uuid'] = "123456789"
351
352                total_string = self.background_job(
353                    process, txtQueue, json_variables)
354
355
356        #if total_string:
357        if True:
358            output_dict['_empty_return'] = 1
359            print json.dumps(total_string)
360            print json.dumps(output_dict)
361       
362        else:
363            error_string = 'Exception encountered executing '+self.module + \
364                ' program: please submit feedback and attach run log'
365            output_dict['error'] = error_string
366            print json.dumps(output_dict)
367
368        #html_base_name = runname + '_plots.html'
369
370        #html_file = os.path.join(runname, self.module, html_base_name)
371
372        #try:
373        #    output_dict['report_html'] = open(html_file).readlines()
374        #except:
375        #    html_error = 'unable to read HTML report from '+html_file
376        #    output_dict['report_html'] = html_error
377
378
379if __name__ == '__main__':
380
381    json_flag = True
382    #json_flag = False
383
384    if (len(sys.argv) < 1):
385        print "\{\"error\":\"bayesian ensemble fit called with no arguments\"\}\n"
386#       print 'exiting now'
387
388    elif len(sys.argv) > 1:
389        json_variables = " "
390        if(json_flag):
391            argv_io_string = StringIO(sys.argv[1])
392            json_variables = json.load(argv_io_string)
393        a = Bayesian_Ensemble_Fit_Drv()
394        a.run_me(json_flag, json_variables, sys.argv[1])
Note: See TracBrowser for help on using the repository browser.