def run(args):
if args and args.filename != "":
project = Project.load_object(args.filename)
default_atoms = []
AtomType.get_from_csv(
settings.DATA_REG.get_file_path("ATOM_SCAT_FACTORS"),
default_atoms.append
)
for atom in project.atom_types.iter_objects():
default_atom = None
for def_atom in default_atoms:
if atom.name == def_atom.name:
default_atom = def_atom
assert default_atom is not None
atom.charge = default_atom.charge
atom.debye = default_atom.debye
project.save_object(args.filename + ".def")
del project
print "Finished!"
def run_refinement(projectf, mixture_index, options):
"""
Runs a refinement setup for
- projectf: project data
- mixture_index: what mixture in the project to use
- options: refinement options
"""
if projectf is not None:
from pyxrd.data import settings
settings.CACHE = None
settings.apply_runtime_settings()
from pyxrd.generic import pool
pool.get_pool()
from pyxrd.project.models import Project
type(Project).object_pool.clear()
project = Project.load_object(None, data=projectf)
del projectf
import gc
gc.collect()
mixture = project.mixtures[mixture_index]
mixture.update_refinement_treestore()
mixture.refiner.setup_context(store=False) # we already have a dumped project
context = mixture.refiner.context
context.options = options
mixture.refiner.refine(stop=pool.pool_stop)
return list(context.best_solution), context.best_residual, (context.record_header, context.records) #@UndefinedVariable
def open_project(self, filename):
# Try to load the project:
with self.ui_error_handler("An error has occurred.\n Your project was not loaded!"):
self.model.current_project = Project.load_object(filename, parent=self.model)
# Set the current filename property and update the title
self.model.current_filename = filename
self.update_title()
def _run_gui(project=None):
# Display a splash screen showing the loading status...
from pkg_resources import resource_filename # @UnresolvedImport
from pyxrd.application.splash import SplashScreen
from pyxrd import __version__
filename = resource_filename(__name__, "application/icons/pyxrd.png")
splash = SplashScreen(filename, __version__)
# Run GUI:
splash.set_message("Loading GUI ...")
# Now we can load these:
from pyxrd.data import settings
from pyxrd.project.models import Project
from pyxrd.application.models import AppModel
from pyxrd.application.views import AppView
from pyxrd.application.controllers import AppController
from pyxrd.generic.gtk_tools.gtkexcepthook import plugin_gtk_exception_hook
filename = settings.ARGS.filename #@UndefinedVariable
# Check if a filename was passed, if so try to load it
if filename != "":
try:
logging.info("Opening project: %s" % filename)
project = Project.load_object(filename)
except IOError:
logging.info("Could not load project file %s: IOError" % filename)
# FIXME the user should be informed of this in a dialog...
# Disable unity overlay scrollbars as they cause bugs with modal windows
os.environ['LIBOVERLAY_SCROLLBAR'] = '0'
os.environ['UBUNTU_MENUPROXY'] = ""
if not settings.DEBUG:
warnings.filterwarnings(action='ignore', category=Warning)
# Close splash screen
if splash: splash.close()
# Nice GUI error handler:
gtk_exception_hook = plugin_gtk_exception_hook()
# setup MVC:
m = AppModel(project=project)
v = AppView()
AppController(m, v, gtk_exception_hook=gtk_exception_hook)
# Free this before continuing
del splash
# lets get this show on the road:
gtk.main()
def run(args):
# batch csv file generator for a file containin a number of projects
if args and args.filename != "":
project = Project.load_object(args.filename)
for i, mixture in enumerate(project.mixtures):
mixture.update_refinement_treestore()
refs = []
props = ("d001", "F1", "F2", "F3", "F4", "W1", "P11_or_P22",)
for node in mixture.refinables.iter_children():
ref = node.object
if ref.refinable and ref.prop in props:
val = ref.value
delta = 0.1
if val > 1.0:
delta = log(val)
ref.value_min = val - delta
ref.value_max = val + delta
refs.append(ref)
combs = list(combinations(refs, 2))
fractions = np.zeros(shape=(len(combs), len(mixture.fractions)))
rps = np.zeros(shape=(len(combs),))
print len(combs) * 9, " calculations to be made!"
for k, (ref1, ref2) in enumerate(combs):
print "\rProgress: %00.f%%" % float(100.0 * k / len(combs)),
for i in range(3):
for j in range(3):
ref1.value = ref1.value_min + float(i) * (ref1.value_max - ref1.value_min) / 2.0
ref2.value = ref2.value_min + float(j) * (ref2.value_max - ref2.value_min) / 2.0
rp = mixture.optimize()
if rp <= 30.0:
inv_rp = 30.0 - rp
fractions[k, :] = np.array(mixture.fractions, dtype=float)
rps[k] = inv_rp
# print "\rProgress: %00f%% - iter %d of 25" % (float(100.0 * k / len(combs)), i*5+(j+1))
print "Phases:"
print mixture.phases
print "Unweighted average:"
print np.average(fractions.transpose(), axis=1, weights=rps)
print np.std(fractions.transpose() * rps, axis=1) / np.sum(rps)
print "Weighted average:"
print np.average(fractions.transpose(), axis=1, weights=rps)
print np.std(fractions.transpose(), axis=1)
print "Average Rp value:"
print np.average(30.0 - rps), "+/-", np.std(30.0 - rps)
del project
print "Finished!"
def setup_project(projectf):
# Only import these at this point, the cause a considerable increase in
# memory usage, so if no projectf was passed to improve_solutions, this
# module does not use more then it needs.
from pyxrd.data import settings
settings.apply_runtime_settings()
from pyxrd.project.models import Project
type(Project).object_pool.clear()
f = StringIO()
f.write(projectf)
project = Project.load_object(f)
f.close()
return project
def run(args):
# batch csv file generator for a file containin a number of projects
if args and args.filename != "":
projects = []
with open(args.filename, 'r') as f:
for project_file in f:
project_file = project_file.rstrip()
print "Parsing: %s" % project_file
project = Project.load_object(project_file)
for i, mixture in enumerate(project.mixtures):
np.savetxt(
"%s/%s" % (os.path.dirname(project_file), os.path.basename(project_file).replace(".pyxrd", "-%d.csv" % i, 1)),
get_result_description(mixture), fmt='%s', delimiter=';'
)
del project
print "Finished!"
def run(args):
"""
This is a simple script that will open a PyXRD project file,
will run a refinement for a certain mixture, and store the results
in an overview file and the best solution as a new project file.
The refinement setup is left unchanged, so be sure you have correctly
defined parameter ranges and chosen a good refinement strategy (CMA-ES
is recommended).
To use this script, launch it using PyXRD's core.py launcher script as:
python core.py -s pyxrd/scripts/refinement_generator.py "$FILENAME###$I###$J"
in which:
- $FILENAME can be replaced with the absolute path to the actual
project filename
- $I is the index of the mixture to refine and
- $J is the 'trial' number, which is added to the record file and to the
best solution project file.
- leave the three # (hashes) where they are, they are used as separators
You can use this script (e.g. on high-performance computing clusters) to
run several iterations of the same project. Reasaons why you would want
to do this are for benchmarking, checking solution reliability, ...
Just change the trial number from e.g. 0 to 49 to have 50 iterations.
"""
## TODO:
## - use a uniform distribution of starting solutions:
## xs = np.random.uniform(size=50)
## ys = np.random.uniform(size=50)
## zs = np.random.uniform(size=50)
##
## When the jobs are submitted, load the project and mixture once,
## create the # of staring solutions and store them in a file (using np IO)
## Then here we can load them and pick the one we need.
##
if args and args.filename != "":
logging.info("Proccessing args...")
project_file, k, mixture_index = tuple(args.filename.split("###", 2))
base_path = os.path.dirname(args.filename)
start_solutions_fname = os.path.join(
base_path,
"start_solutions %s mixture %s" % (os.path.basename(project_file), mixture_index)
)
stop_event = multiprocessing.Event()
logging.info("Loading project file...")
project = Project.load_object(project_file)
logging.info(" ".join(["Running Project", os.path.basename(project_file), "Trial", k]))
for i, mixture in enumerate(project.mixtures):
if i == int(mixture_index):
if B_DO_PROFILING:
pr = cProfile.Profile()
pr.enable()
try:
with mixture.data_changed.hold():
mixture.update_refinement_treestore()
mixture.refiner.setup_context(store=True)
if int(k) == 0: #First run, create solutions & store for later use:
start_solutions = mixture.refiner.context.get_uniform_solutions(50)
np.savetxt(start_solutions_fname, start_solutions)
else:
start_solutions = np.loadtxt(start_solutions_fname)
mixture.refiner.context.set_initial_solution(start_solutions[k, ...])
mixture.optimizer.optimize()
mixture.refiner.refine(stop=stop_event)
except:
raise
finally:
if B_DO_PROFILING:
pr.disable()
with open("pyxrd_stats", "w+") as f:
sortby = 'cumulative'
ps = pstats.Stats(pr, stream=f).sort_stats(sortby)
ps.print_stats()
context = mixture.refiner.context
recordf = os.path.basename(project_file).replace(".pyxrd", "")
recordf = base_path + "/" + "record#" + str(k) + " " + recordf + " " + mixture.name
with codecs.open(recordf, 'w', 'utf-8') as f:
f.write("################################################################################\n")
f.write(recordf + "\n")
f.write("Mixture " + str(i) + " and trial " + str(k) + "\n")
f.write("Property name, initial, best, min, max" + "\n")
for j, ref_prop in enumerate(context.ref_props):
line = ", ".join([
ref_prop.get_descriptor(),
str(context.initial_solution[j]),
str(context.best_solution[j]),
str(ref_prop.value_min),
str(ref_prop.value_max),
])
f.write(line + "\n")
f.write("################################################################################\n")
def write_records(f, record_header, records):
f.write(", ".join(record_header) + "\n")
for record in records:
f.write(", ".join(map(lambda f: "%.7f" % f, record)) + "\n")
f.write("################################################################################\n")
if context.record_header is not None:
write_records(f, context.record_header, context.records)
if hasattr(context, "pcma_records"):
for record_header, records in context.pcma_records:
write_records(f, record_header, records)
# Apply found solution and save:
context.apply_best_solution()
mixture.optimizer.optimize()
project_file_output = base_path + "/" + os.path.basename(project_file).replace(".pyxrd", "") + " - mixture %s - trial %s.pyxrd" % (str(i), str(k))
project.save_object(file=project_file_output)
pass # end
def setUp(self):
self.project = Project.load_object(resource_filename("test.test_mixture", "test refinement.pyxrd"))
self.mixture = self.project.mixtures[0]
