def process_collection(summary_content=None, report_list=[], publish=True, run_number=None):
"""
Process a collection of reports into on final report
"""
plot_html = ''
script = ''
if summary_content is not None:
plot_html += "<div>%s</div>\n" % summary_content
for r in report_list:
script += r.script
plot_html += "<div>%s</div>\n" % r.report
plot_html += "<table style='width:100%'>\n"
plot_html += "<tr>\n"
for p in r.plots:
plot_html += "<td>%s</td>\n" % p
plot_html += "</tr>\n"
plot_html += "</table>\n"
# Send to the web monitor as needed
if run_number is None and len(report_list)>0:
run_number = report_list[0].data_info.run_number
if publish:
try:
from postprocessing.publish_plot import publish_plot
publish_plot("REF_M", run_number, files={'file': plot_html})
except:
logging.error("Could not publish web report: %s", sys.exc_value)
return plot_html, script
def process_collection(summary_content=None,
report_list=[],
publish=True,
run_number=None):
"""
Process a collection of reports into on final report
:param str summary_content: html content at the top of the report
:param list report_list: list of html contents to be appended at the bottom of the page
:param bool publish: if True, the report will be sent to the live data server
:param int run_number: run number to associate this report with
"""
logger.notice("Processing... %s" % len(report_list))
plot_html = '<div></div>'
script = ''
if summary_content is not None:
plot_html += "<div>%s</div>\n" % summary_content
if report_list:
plot_html += report_list[0].report
for report in report_list:
script += report.script
plot_html += "<div>%s</div>\n" % report.cross_section_info
plot_html += "<table style='width:100%'>\n"
plot_html += "<tr>\n"
for plot in report.plots:
if plot is not None:
plot_html += "<td>%s</td>\n" % plot
plot_html += "</tr>\n"
plot_html += "</table>\n"
plot_html += "<hr>\n"
# Send to the web monitor as needed
if run_number is None and report_list:
run_number = report_list[0].data_info.run_number
if publish:
# Depending on where we run, we might get our publisher from
# different places, or not at all.
_publisher_found = False
try: # version on autoreduce
from postprocessing.publish_plot import publish_plot
_publisher_found = True
except ImportError: # version on instrument computers
from finddata.publish_plot import publish_plot
_publisher_found = True
if _publisher_found:
publish_plot("REF_M", run_number, files={'file': str(plot_html)})
else:
logger.error("Could not publish web report: %s" %
sys.exc_info()[1])
return plot_html, script
plots = generate_plots(run_number, input)
info = ''
try:
n_evts = input.getNumberEvents()
seq_number = input.getRun()['sequence_number'].value[0]
seq_total = input.getRun()['sequence_total'].value[0]
info = "<div>Events: %s</div>\n" % n_evts
info += "<div>Sequence: %s of %s</div>\n" % (seq_number, seq_total)
except:
info = "<div>Error: %s</div>\n" % sys.exc_value
plot_html = "<div>Live data</div>\n"
plot_html += info
plot_html += refl_info
plot_html += "<table style='width:100%'>\n"
plot_html += "<tr>\n"
for plot in plots:
plot_html += "<td>%s</td>\n" % plot
plot_html += "</tr>\n"
plot_html += "</table>\n"
plot_html += "<hr>\n"
mantid.logger.information('Posting plot of run %s' % run_number)
try: # version on autoreduce
from postprocessing.publish_plot import publish_plot
except ImportError: # version on instrument computers
from finddata import publish_plot
request = publish_plot('REF_L', run_number, files={'file':plot_html})
mantid.logger.information("post returned %d" % request.status_code)
def publish_plots(run_number):
from postprocessing.publish_plot import publish_plot
plot_html_inst = '<div><img style="max-width:90%" src="/static/web_monitor/images/MANDI_{0}_IV.png" alt="Instrument view"></div>\n'.format(
run_number) # noqa: E501
publish_plot("MANDI", run_number, files={'file': plot_html_inst})
plot_html += reduction_info
plot_html += "<table style='width:100%'>\n"
plot_html += "<tr>\n"
for plot in plots:
plot_html += "<td>%s</td>\n" % plot
plot_html += "</tr>\n"
plot_html += "</table>\n"
plot_html += "<hr>\n"
plot_html += pol_info
if DEBUG:
logfile.write("\nhtml ready\n")
#logfile.write(plot_html)
try:
mantid.logger.information('Posting plot of run %s' % run_number)
try: # version on autoreduce
from postprocessing.publish_plot import publish_plot
except ImportError: # version on instrument computers
from finddata import publish_plot
request = publish_plot('REF_M', run_number, files={'file': plot_html})
except:
exc_type, exc_value, exc_traceback = sys.exc_info()
if DEBUG:
logfile.write('\n' + exc_value + '\n')
for line in traceback.format_exception(exc_type, exc_value,
exc_traceback):
logfile.write(line)
if DEBUG:
logfile.write("DONE\n")
logfile.close()
ConvertUnits(InputWorkspace=wksp_name,
OutputWorkspace=wksp_name,
Target="dSpacing")
# save a picture of the normalized ritveld data
banklabels = [
'bank 1 - 15 deg', 'bank 2 - 31 deg', 'bank 3 - 67 deg',
'bank 4 - 122 deg', 'bank 5 - 154 deg', 'bank 6 - 7 deg'
]
spectratoshow = [2, 3, 4, 5]
saveplot1d_args = dict(InputWorkspace=wksp_name,
SpectraList=spectratoshow,
SpectraNames=banklabels)
post_image = True
if post_image:
div = SavePlot1D(OutputType='plotly', **saveplot1d_args)
from postprocessing.publish_plot import publish_plot
request = publish_plot('NOM', samRun, files={'file': div})
print("post returned %d" % request.status_code)
print("resulting document:")
print(request.text)
else:
filename = os.path.join(outputDir, wksp_name + '.html')
SavePlot1D(OutputFilename=filename,
OutputType='plotly-full',
**saveplot1d_args)
print('saved', filename)
datadict = datafile.to_dict()
table = '<div></div><p></p><table class="info display">'
row = '<tr><td>{}</td><td>{}</td></tr>'
table += row.format('Scan', '<b>{} - {}</b>'.format(datadict.get('metadata').get('scan', ''), datadict.get('metadata').get('scan_title', '')))
table += row.format('Experiment', '{} - {}'.format(datadict.get('metadata').get('experiment_number', ''), datadict.get('metadata').get('experiment', '')))
table += row.format('IPTS', datadict.get('metadata').get('proposal', ''))
table += row.format('Run start', datadict.get('metadata').get('date', '') + ' ' + datadict.get('metadata').get('time', ''))
table += row.format('Total counts', datadict.get('metadata').get('Sum of Counts', ''))
table += row.format('Command', datadict.get('metadata').get('command', ''))
table += '</table><p></p>'
try:
runNumber = datafile.to_dict()['indexed']['run_number']
request = publish_plot('HB2A', runNumber, files={'file': table+div})
except KeyError:
print("This file doesn't have a run number")
################################################################################
# Create suammary csv
projection = ["location", "metadata.completed", "metadata.command", "metadata.scan_title", "indexed.scan_number", "metadata.samplename"]
datafiles = oncat.Datafile.list(
facility="HFIR",
instrument="HB2A",
experiment=ipts,
projection=projection
)
ClearRHSWorkspace=True)
simpleapi.DeleteWorkspace(Workspace=vanback)
simpleapi.CompressEvents(InputWorkspace=van, OutputWorkspace=van)
simpleapi.ConvertUnits(InputWorkspace=van, OutputWorkspace=van,
Target='dSpacing', EMode='Elastic')
simpleapi.StripVanadiumPeaks(InputWorkspace=van, OutputWorkspace=van,
BackgroundType='Quadratic', PeakPositionTolerance=.05)
smooth(van)
if van is not None:
simpleapi.Divide(LHSWorkspace=output, RHSWorkspace=van, OutputWorkspace=output)
##### generate plot and post
div = simpleapi.SavePlot1D(InputWorkspace=output, OutputType='plotly')
runNumber = simpleapi.mtd[output].getRunNumber()
if runNumber > 0: # it is 0 between runs
mantid.logger.information('Posting plot of PG3_%s' % runNumber)
try: # version on autoreduce
from postprocessing.publish_plot import publish_plot
except ImportError: # version on instrument computers
from finddata import publish_plot
request = publish_plot('PG3', runNumber, files={'file':div})
mantid.logger.information("post returned %d" % request.status_code)
mantid.logger.information("resulting document:")
mantid.logger.information(str(request.text))
else:
mantid.logger.information('Not posting becuase run number is not greater than zero: %s' % runNumber)
oncat = pyoncat.ONCat(
'https://oncat.ornl.gov',
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
token_getter=token_store.get_token,
token_setter=token_store.set_token,
flow=pyoncat.RESOURCE_OWNER_CREDENTIALS_FLOW
)
if token_store.get_token() is None:
username = getpass.getuser()
password = getpass.getpass()
oncat.login(username, password)
filename = sys.argv[1]
ipts = filename.split('/')[3]
datafile = oncat.Datafile.retrieve(
filename,
facility="HFIR",
instrument="HB2A",
experiment=ipts,
projection=["indexed.run_number"],
)
try:
runNumber = datafile.to_dict()['indexed']['run_number']
request = publish_plot('HB2A', runNumber, files={'file': div}, config='/SNS/users/rwp/post_processing.conf')
except KeyError:
print("This file doesn't have a run number")
# do some plots
fig = plt.gcf()
numfig = len(config.plots)
fig.set_size_inches(5.0, 5.0 * (numfig + 1))
for i in range(numfig):
plt.subplot(numfig + 1, 1, i + 2)
if config.useCC == "True" and CCsucceded:
makePlot(mdcc, config.plots[i], config.can_do_norm)
else:
makePlot(mdraw, config.plots[i], config.can_do_norm)
plt.subplot(numfig + 1, 1, 1)
raw = Rebin(raw, str(kmin) + ',' + str(kmax - kmin) + ',' + str(kmax))
makeInstrumentView(raw)
figfile = BytesIO()
plt.savefig(figfile, bbox_inches='tight')
plt.close()
figfile.seek(0)
figdata_png = base64.b64encode(figfile.getvalue())
try:
figdata_png = figdata_png.decode()
except:
pass
div = '<div><img alt="{}" src="data:image/png;base64,{}" /></div>'.format(
output_file, figdata_png)
with open("div.txt", "w") as f:
f.write(div)
request = publish_plot('CORELLI', runNumber, files={'file': div})
print(request)
CharacterizationRunsFile=char_file,
LowResRef=0,
RemovePromptPulseWidth=50,
Binning=-0.0008,
BinInDspace=True,
BackgroundSmoothParams="5,2",
FilterBadPulses=10,
ScaleData=100,
SaveAs="gsas topas and fullprof",
OutputDirectory=outputDir,
FinalDataUnits="dSpacing",
)
GeneratePythonScript(InputWorkspace="PG3_" + runNumber, Filename=os.path.join(outputDir, "PG3_" + runNumber + ".py"))
ConvertUnits(InputWorkspace="PG3_" + runNumber, OutputWorkspace="PG3_" + runNumber, Target="dSpacing", EMode="Elastic")
# interactive plots
post_image = True
if post_image:
div = SavePlot1D(InputWorkspace="PG3_" + runNumber, OutputType="plotly")
from postprocessing.publish_plot import publish_plot
request = publish_plot("PG3", runNumber, files={"file": div})
print "post returned %d" % request.status_code
print "resulting document:"
print request.text
else:
filename = os.path.join(outputDir, "PG3_%s.html" % runNumber)
SavePlot1D(InputWorkspace="PG3_" + runNumber, OutputType="plotly-full", OutputFilename=filename)
print "saved", filename
if powder:
from mantid.simpleapi import LoadWAND, WANDPowderReduction, SavePlot1D, SaveFocusedXYE, Scale
data = LoadWAND(filename, Grouping='4x4')
runNumber = data.getRunNumber()
cal = get_vanadium(runNumber)
WANDPowderReduction(InputWorkspace=data,
CalibrationWorkspace=cal,
Target='Theta',
NumberBins=1200,
OutputWorkspace='reduced')
Scale(InputWorkspace='reduced',OutputWorkspace='reduced',Factor=100)
SaveFocusedXYE('reduced', Filename=os.path.join(outdir, output_file+'.xye'), SplitFiles=False, IncludeHeader=False)
div = SavePlot1D('reduced', OutputType='plotly')
request = publish_plot('HB2C', runNumber, files={'file': div})
else: # Single Crystal
with h5py.File(filename, 'r') as f:
offset = decode(f['/entry/DASlogs/HB2C:Mot:s2.RBV/average_value'].value[0])
title = decode(f['/entry/title'].value[0])
mon = decode(f['/entry/monitor1/total_counts'].value[0])
duration = decode(f['/entry/duration'].value[0])
run_number = decode(f['/entry/run_number'].value[0])
bc = np.zeros((512*480*8))
for b in range(8):
bc += np.bincount(f['/entry/bank'+str(b+1)+'_events/event_id'].value,
minlength=512*480*8)
bc = bc.reshape((480*8, 512))
bc = (bc[::4, ::4] + bc[1::4, ::4] + bc[2::4, ::4] + bc[3::4, ::4]
