Add correct wrapping for C++-instantiated objects available through global registries, e.g. when loading an XML file. The objects are decorated with the python functions when accessed through the global registries GetObj().

Correct minor issues in PowderPattern plotting and Crystal bond orders.
Move global object registries to pyobjcryst.globals.
Change the liobjcryst version in conda build config

Author: vincefn

conda-recipe/conda_build_config.yaml

@@ -8,7 +8,7 @@ numpy:
   - 1.11
 
 libobjcryst:
-  - 2017.2.*
+  - 2021.1.2
 
 boost:
   - 1.67

src/extensions/globaloptim_ext.cpp

@@ -19,6 +19,7 @@
 *****************************************************************************/
 
 #include <boost/python/class.hpp>
+#include <boost/python/def.hpp>
 #include <boost/python/copy_const_reference.hpp>
 #include <boost/python/enum.hpp>
 
@@ -65,28 +66,28 @@ class MonteCarloObjWrap: public MonteCarloObj, public wrapper<MonteCarloObj>
 
 };
 
-void run_optimize(MonteCarloObjWrap& obj, long nbSteps, const bool silent,
+void run_optimize(MonteCarloObj& obj, long nbSteps, const bool silent,
         const double finalcost, const double maxTime)
 {
     CaptureStdOut gag;
     obj.Optimize(nbSteps, silent, finalcost, maxTime);
 }
 
-void multirun_optimize(MonteCarloObjWrap& obj, long nbCycle, long nbSteps,
+void multirun_optimize(MonteCarloObj& obj, long nbCycle, long nbSteps,
         const bool silent, const double finalcost, const double maxTime)
 {
     CaptureStdOut gag;
     obj.MultiRunOptimize(nbCycle, nbSteps, silent, finalcost, maxTime);
 }
 
-void mc_sa(MonteCarloObjWrap& obj, long nbSteps, const bool silent,
+void mc_sa(MonteCarloObj& obj, long nbSteps, const bool silent,
         const double finalcost, const double maxTime)
 {
     CaptureStdOut gag;
     obj.RunSimulatedAnnealing(nbSteps, silent, finalcost, maxTime);
 }
 
-void mc_pt(MonteCarloObjWrap& obj, long nbSteps, const bool silent,
+void mc_pt(MonteCarloObj& obj, long nbSteps, const bool silent,
         const double finalcost, const double maxTime)
 {
     CaptureStdOut gag;
@@ -105,6 +106,9 @@ void mc_random_lsq(MonteCarloObjWrap& obj, long nbCycle)
 
 void wrap_globaloptim()
 {
+    // Global object registry
+    scope().attr("gOptimizationObjRegistry") = boost::cref(gOptimizationObjRegistry);
+
     enum_<AnnealingSchedule>("AnnealingSchedule")
         .value("CONSTANT", ANNEALING_CONSTANT)
         .value("BOLTZMANN", ANNEALING_BOLTZMANN)
@@ -122,7 +126,10 @@ void wrap_globaloptim()
         .value("PARALLEL_TEMPERING_MULTI", GLOBAL_OPTIM_PARALLEL_TEMPERING_MULTI)
         ;
 
-    class_<MonteCarloObjWrap>("MonteCarlo")
+    class_<MonteCarloObjWrap, boost::noncopyable>("MonteCarlo")
+        .def(init<>())
+        .def(init<const MonteCarloObj&>(bp::arg("old")))
+        .def(init<const std::string&>(bp::arg("name")))
         //////////////// OptimizationObj methods
         .def("RandomizeStartingConfig", &MonteCarloObj::RandomizeStartingConfig)
         .def("Optimize", &run_optimize,
@@ -161,9 +168,9 @@ void wrap_globaloptim()
         .def("GetFullRefinableObj", &MonteCarloObj::GetFullRefinableObj,
             bp::arg("rebuild")=true,
             with_custodian_and_ward_postcall<1,0, return_internal_reference<> >())
-        .def("GetName", &MonteCarloObj::GetName,
-            return_value_policy<copy_const_reference>())
+        .def("GetName", &MonteCarloObj::GetName, return_value_policy<copy_const_reference>())
         .def("SetName", &MonteCarloObj::SetName)
+        .def("GetClassName", &MonteCarloObj::GetClassName)
         .def("Print", &MonteCarloObj::Print, &MonteCarloObj::Print)
         .def("RestoreBestConfiguration", &MonteCarloObj::RestoreBestConfiguration)
         .def("GetNbParamSet", &MonteCarloObj::GetNbParamSet)

src/extensions/objregistry_ext.cpp

@@ -56,6 +56,20 @@ template <class T> bp::object getObjSlice(ObjRegistry<T>& o, bp::slice& s)
     return l[s];
 }
 
+// Get a MonteCarloObj by dynamic casting. This assumes that the caller (from python)
+// first checked the correct type e.g. using GetClassName()
+template <class T> MonteCarloObj& getObjCastMonteCarlo(ObjRegistry<T>& reg, const unsigned int i)
+{
+    T* obj = &reg.GetObj(i);
+    MonteCarloObj *p = dynamic_cast<MonteCarloObj*>(obj);
+    return *p;
+}
+
+// Explicit specialization for ZAtom which is not polymorphic
+template <> MonteCarloObj& getObjCastMonteCarlo(ObjRegistry<ZAtom>& reg, const unsigned int i)
+{
+    throw ObjCryst::ObjCrystException("Cannot cast a ZAtom to a MonteCarloObj");
+}
 
 
 /* Wrap all the class methods for the template class */
@@ -118,6 +132,9 @@ wrapClass(class_<ObjRegistry<T> > & c)
     // which will effectively invalidate the iterator...
     .def("__iter__", range<return_value_policy<reference_existing_object> >
                        (&ObjRegistry<T>::list_begin, &ObjRegistry<T>::list_end))
+    // Special casting functions so base class object registries can still
+    // provide access to the correct python object
+    .def("_getObjCastMonteCarlo", &getObjCastMonteCarlo<T>, return_internal_reference<>())
     ;
 }
 

src/extensions/powderpattern_ext.cpp

@@ -316,6 +316,7 @@ void wrap_powderpattern()
         .def("GetChi2", &PowderPattern::GetChi2)
         .def("GetIntegratedChi2", &PowderPattern::GetIntegratedChi2)
         .def("GetLogLikelihood", &PowderPattern::GetLogLikelihood)
+        .def("Prepare", &PowderPattern::Prepare)
         .add_property("mur", &PowderPattern::GetMuR, &PowderPattern::SetMuR)
         .add_property("r", &PowderPattern::GetR)
         .add_property("r_integrated", &PowderPattern::GetIntegratedR)

src/pyobjcryst/crystal.py

@@ -30,16 +30,17 @@
 """
 
 __all__ = ["Crystal", "BumpMergePar", "CreateCrystalFromCIF",
-           "create_crystal_from_cif", "gCrystalRegistry"]
+           "create_crystal_from_cif"]
 
 import warnings
+from types import MethodType
 from urllib.request import urlopen
 from multiprocessing import current_process
 import numpy as np
 from pyobjcryst._pyobjcryst import Crystal as Crystal_orig
 from pyobjcryst._pyobjcryst import BumpMergePar
 from pyobjcryst._pyobjcryst import CreateCrystalFromCIF as CreateCrystalFromCIF_orig
-from pyobjcryst._pyobjcryst import gCrystalRegistry
+from .refinableobj import wrap_boost_refinableobjregistry
 
 try:
     import py3Dmol
@@ -232,7 +233,7 @@ def _display_list(self, xmin=0, xmax=1, ymin=0, ymax=1, zmin=0, zmax=1, enantiom
                                           'symbol': symbol, 'bonds': [], 'bondOrder': []}
                 for bond in scatt.IterBond():
                     o = bond.BondOrder
-                    if o == 0:
+                    if o < 1:
                         o = 1
                     i1 = bond.GetAtom1().int_ptr()
                     i2 = bond.GetAtom2().int_ptr()
@@ -630,5 +631,17 @@ def create_crystal_from_cif(file, oneScatteringPowerPerElement=False,
     return c
 
 
+def wrap_boost_crystal(c: Crystal):
+    """
+    This function is used to wrap a C++ Object by adding the python methods to it.
+
+    :param c: the C++ created object to which the python function must be added.
+    """
+    if '_display_cif' not in dir(c):
+        for func in ['CIFOutput', 'UpdateDisplay', 'disable_display_update', 'enable_display_update',
+                     '_display_cif', '_display_list', 'display_3d', 'widget_3d', '_widget_update',
+                     '_widget_on_change_parameter']:
+            exec("c.%s = MethodType(Crystal.%s, c)" % (func, func))
+
 # PEP8, functions should be lowercase
 CreateCrystalFromCIF = create_crystal_from_cif

src/pyobjcryst/globaloptim.py

@@ -21,31 +21,46 @@
 __all__ = ["MonteCarlo", "AnnealingSchedule", "GlobalOptimType"]
 
 import warnings
+from types import MethodType
+
 try:
     import ipywidgets as widgets
 except ImportError:
     widgets = None
-from pyobjcryst._pyobjcryst import MonteCarlo as MonteCarlo_orig, AnnealingSchedule, GlobalOptimType
+from pyobjcryst._pyobjcryst import MonteCarlo as MonteCarlo_orig, AnnealingSchedule, \
+    GlobalOptimType, OptimizationObjRegistry
 from .refinableobj import *
 
 
 class MonteCarlo(MonteCarlo_orig):
 
     def Optimize(self, nb_step: int, final_cost=0, max_time=-1):
         self._fix_parameters_for_global_optim()
-        super().Optimize(int(nb_step), True, final_cost, max_time)
+        if type(self) == MonteCarlo_orig:
+            self._Optimize(int(nb_step), True, final_cost, max_time)
+        else:
+            super().Optimize(int(nb_step), True, final_cost, max_time)
 
     def MultiRunOptimize(self, nb_run: int, nb_step: int, final_cost=0, max_time=-1):
         self._fix_parameters_for_global_optim()
-        super().MultiRunOptimize(int(nb_run), int(nb_step), True, final_cost, max_time)
+        if type(self) == MonteCarlo_orig:
+            self._MultiRunOptimize(int(nb_run), int(nb_step), True, final_cost, max_time)
+        else:
+            super().MultiRunOptimize(int(nb_run), int(nb_step), True, final_cost, max_time)
 
     def RunSimulatedAnnealing(self, nb_step: int, final_cost=0, max_time=-1):
         self._fix_parameters_for_global_optim()
-        super().RunSimulatedAnnealing(int(nb_step), True, final_cost, max_time)
+        if type(self) == MonteCarlo_orig:
+            self._RunSimulatedAnnealing(int(nb_step), True, final_cost, max_time)
+        else:
+            super().RunSimulatedAnnealing(int(nb_step), True, final_cost, max_time)
 
     def RunParallelTempering(self, nb_step: int, final_cost=0, max_time=-1):
         self._fix_parameters_for_global_optim()
-        super().RunParallelTempering(int(nb_step), True, final_cost, max_time)
+        if type(self) == MonteCarlo_orig:
+            self._RunParallelTempering(int(nb_step), True, final_cost, max_time)
+        else:
+            super().RunParallelTempering(int(nb_step), True, final_cost, max_time)
 
     def _fix_parameters_for_global_optim(self):
         # Fix parameters that should not be optimised in a MonterCarlo run
@@ -58,7 +73,7 @@ def _fix_parameters_for_global_optim(self):
 
     def widget(self):
         """
-        Display a simple widget for this MonteCarloObj, which only updates the current
+        Display a simple widget for this MonteCarlo, which only updates the current
         cost (log-likelihood). Requires ipywidgets
         """
         if widgets is None:
@@ -101,3 +116,49 @@ def _widget_update(self):
         else:
             self._widget_llk.value = "LLK=%12.2f                        " % self.llk
         self._widget_llk.layout.width = '%dem' % len(self._widget_llk.value)
+
+
+def wrap_boost_montecarlo(c: MonteCarlo):
+    """
+    This function is used to wrap a C++ Object by adding the python methods to it.
+
+    :param c: the C++ created object to which the python function must be added.
+    """
+    if 'widget' not in dir(c):
+        for func in ['Optimize', 'MultiRunOptimize', 'RunSimulatedAnnealing', 'RunParallelTempering']:
+            # We keep access to the original functions... Yes, it's a kludge...
+            exec("c._%s = c.%s" % (func, func))
+        for func in ['Optimize', 'MultiRunOptimize', 'RunSimulatedAnnealing', 'RunParallelTempering',
+                     '_fix_parameters_for_global_optim', 'widget', 'UpdateDisplay',
+                     'disable_display_update', 'enable_display_update', '_widget_update']:
+            exec("c.%s = MethodType(MonteCarlo.%s, c)" % (func, func))
+
+
+class OptimizationObjRegistryWrapper(OptimizationObjRegistry):
+    """
+    Wrapper class with a GetObj() method which can correctly wrap C++ objects with
+    the python methods. This is only needed when the objects have been created
+    from C++, e.g. when loading an XML file.
+    """
+
+    def GetObj(self, i):
+        o = self._GetObj(i)
+        # TODO
+        print("Casting OptimizationObj to MonteCarlo and wrapping..")
+        # We get the object as an OptimizationObj, which prevents access to some functions
+        # So we use this function to cast to a MonteCarloObj
+        o = self._getObjCastMonteCarlo(i)
+        wrap_boost_montecarlo(o)
+        return o
+
+
+def wrap_boost_optimizationobjregistry(o):
+    """
+    This function is used to wrap a C++ Object by adding the python methods to it.
+
+    :param c: the C++ created object to which the python function must be added.
+    """
+    # TODO: moving the original function is not very pretty. Is there a better way ?
+    if '_GetObj' not in dir(o):
+        o._GetObj = o.GetObj
+        o.GetObj = MethodType(OptimizationObjRegistryWrapper.GetObj, o)

src/pyobjcryst/globals.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python
+##############################################################################
+#
+# globals
+#
+# File coded by:    Vincent Favre-Nicolin
+#
+# See AUTHORS.txt for a list of people who contributed.
+# See LICENSE.txt for license information.
+#
+##############################################################################
+
+""" Global objects are exposed here. These are the main objects registries,
+which are tweaked to wrap pure C++ objects with the python methods.
+"""
+
+__all__ = ["gCrystalRegistry","gPowderPatternRegistry", "gRefinableObjRegistry", "gScattererRegistry",
+           "gOptimizationObjRegistry", "gTopRefinableObjRegistry"]
+
+from .refinableobj import wrap_boost_refinableobjregistry
+from .globaloptim import wrap_boost_optimizationobjregistry
+from pyobjcryst._pyobjcryst import gCrystalRegistry
+from pyobjcryst._pyobjcryst import gOptimizationObjRegistry
+from pyobjcryst._pyobjcryst import gPowderPatternRegistry
+from pyobjcryst._pyobjcryst import gRefinableObjRegistry
+from pyobjcryst._pyobjcryst import gScattererRegistry
+from pyobjcryst._pyobjcryst import gTopRefinableObjRegistry
+
+# Wrap registries with python methods
+wrap_boost_refinableobjregistry(gCrystalRegistry)
+wrap_boost_refinableobjregistry(gPowderPatternRegistry)
+wrap_boost_refinableobjregistry(gRefinableObjRegistry)
+wrap_boost_refinableobjregistry(gTopRefinableObjRegistry)
+wrap_boost_optimizationobjregistry(gOptimizationObjRegistry)

src/pyobjcryst/io.py

@@ -31,10 +31,9 @@
 import gzip
 import os
 from pyobjcryst._pyobjcryst import XMLCrystTag, \
-    XMLCrystFileLoadAllObject as XMLCrystFileLoadAllObject_orig,\
+    XMLCrystFileLoadAllObject as XMLCrystFileLoadAllObject_orig, \
     XMLCrystFileSaveGlobal as XMLCrystFileSaveGlobal_orig
-
-from pyobjcryst._pyobjcryst import gTopRefinableObjRegistry
+from .globals import gTopRefinableObjRegistry
 
 
 def xml_cryst_file_load_all_object(file, verbose=False):