libhoomd/python/hoomd_module.cc

   1 /*
   2 Highly Optimized Object-oriented Many-particle Dynamics -- Blue Edition
   3 (HOOMD-blue) Open Source Software License Copyright 2009-2014 The Regents of
   4 the University of Michigan All rights reserved.
   5
   6 HOOMD-blue may contain modifications ("Contributions") provided, and to which
   7 copyright is held, by various Contributors who have granted The Regents of the
   8 University of Michigan the right to modify and/or distribute such Contributions.
   9
  10 You may redistribute, use, and create derivate works of HOOMD-blue, in source
  11 and binary forms, provided you abide by the following conditions:
  12
  13 * Redistributions of source code must retain the above copyright notice, this
  14 list of conditions, and the following disclaimer both in the code and
  15 prominently in any materials provided with the distribution.
  16
  17 * Redistributions in binary form must reproduce the above copyright notice, this
  18 list of conditions, and the following disclaimer in the documentation and/or
  19 other materials provided with the distribution.
  20
  21 * All publications and presentations based on HOOMD-blue, including any reports
  22 or published results obtained, in whole or in part, with HOOMD-blue, will
  23 acknowledge its use according to the terms posted at the time of submission on:
  24 http://codeblue.umich.edu/hoomd-blue/citations.html
  25
  26 * Any electronic documents citing HOOMD-Blue will link to the HOOMD-Blue website:
  27 http://codeblue.umich.edu/hoomd-blue/
  28
  29 * Apart from the above required attributions, neither the name of the copyright
  30 holder nor the names of HOOMD-blue's contributors may be used to endorse or
  31 promote products derived from this software without specific prior written
  32 permission.
  33
  34 Disclaimer
  35
  36 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS ``AS IS'' AND
  37 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  38 WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR ANY
  39 WARRANTIES THAT THIS SOFTWARE IS FREE OF INFRINGEMENT ARE DISCLAIMED.
  40
  41 IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  42 INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  43 BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  44 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  45 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  46 OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  47 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48 */
  49
  50 // Maintainer: joaander All developers are free to add the calls needed to export their modules
  51
  52 // temporarily work around issues with the new boost fileystem libraries
  53 // http://www.boost.org/doc/libs/1_46_1/libs/filesystem/v3/doc/index.htm
  54
  55 #ifdef WIN32
  56 #pragma warning( push )
  57 #pragma warning( disable : 4103 4244 4267 )
  58 #endif
  59
  60 #include "HOOMDMath.h"
  61 #include "ClockSource.h"
  62 #include "Profiler.h"
  63 #include "ParticleData.h"
  64 #include "RigidData.h"
  65 #include "SystemDefinition.h"
  66 #include "BondedGroupData.h"
  67 #include "ExecutionConfiguration.h"
  68 #include "Initializers.h"
  69 #include "HOOMDInitializer.h"
  70 #include "HOOMDBinaryInitializer.h"
  71 #include "RandomGenerator.h"
  72 #include "Compute.h"
  73 #include "CellList.h"
  74 #include "ForceCompute.h"
  75 #include "ForceConstraint.h"
  76 #include "ConstForceCompute.h"
  77 #include "ConstExternalFieldDipoleForceCompute.h"
  78 #include "HarmonicAngleForceCompute.h"
  79 #include "TableAngleForceCompute.h"
  80 #include "HarmonicDihedralForceCompute.h"
  81 #include "TableDihedralForceCompute.h"
  82 #include "HarmonicImproperForceCompute.h"
  83 #include "CGCMMAngleForceCompute.h"
  84 #include "CGCMMForceCompute.h"
  85 #include "TablePotential.h"
  86 #include "BondTablePotential.h"
  87 #include "LJWallForceCompute.h"
  88 #include "AllPairPotentials.h"
  89 #include "AllBondPotentials.h"
  90 #include "AllTripletPotentials.h"
  91 #include "ComputeThermo.h"
  92 #include "NeighborList.h"
  93 #include "NeighborListBinned.h"
  94 #include "Analyzer.h"
  95 #include "IMDInterface.h"
  96 #include "HOOMDDumpWriter.h"
  97 #include "HOOMDBinaryDumpWriter.h"
  98 #include "PDBDumpWriter.h"
  99 #include "MOL2DumpWriter.h"
 100 #include "DCDDumpWriter.h"
 101 #include "Logger.h"
 102 #include "MSDAnalyzer.h"
 103 #include "Updater.h"
 104 #include "Integrator.h"
 105 #include "IntegratorTwoStep.h"
 106 #include "IntegrationMethodTwoStep.h"
 107 #include "TwoStepNVE.h"
 108 #include "TwoStepNVT.h"
 109 #include "TwoStepNVTMTK.h"
 110 #include "TwoStepBDNVT.h"
 111 #include "TwoStepNPTMTK.h"
 112 #include "TwoStepBerendsen.h"
 113 #include "TwoStepNVERigid.h"
 114 #include "TwoStepNVTRigid.h"
 115 #include "TwoStepNPTRigid.h"
 116 #include "TwoStepNPHRigid.h"
 117 #include "TwoStepBDNVTRigid.h"
 118 #include "TempRescaleUpdater.h"
 119 #include "ZeroMomentumUpdater.h"
 120 #include "FIREEnergyMinimizer.h"
 121 #include "FIREEnergyMinimizerRigid.h"
 122 #include "SFCPackUpdater.h"
 123 #include "BoxResizeUpdater.h"
 124 #include "Enforce2DUpdater.h"
 125 #include "System.h"
 126 #include "Variant.h"
 127 #include "EAMForceCompute.h"
 128 #include "ConstraintSphere.h"
 129 #include "PotentialPairDPDThermo.h"
 130 #include "EvaluatorTersoff.h"
 131 #include "PotentialPair.h"
 132 #include "PotentialTersoff.h"
 133 #include "PPPMForceCompute.h"
 134 #include "AllExternalPotentials.h"
 135 #include "Messenger.h"
 136
 137 // include GPU classes
 138 #ifdef ENABLE_CUDA
 139 #include <cuda.h>
 140 #include "CellListGPU.h"
 141 #include "TwoStepNVEGPU.h"
 142 #include "TwoStepNVTGPU.h"
 143 #include "TwoStepBDNVTGPU.h"
 144 #include "TwoStepNPTMTKGPU.h"
 145 #include "TwoStepNVTMTKGPU.h"
 146 #include "TwoStepBerendsenGPU.h"
 147 #include "TwoStepNVERigidGPU.h"
 148 #include "TwoStepNVTRigidGPU.h"
 149 #include "TwoStepNPHRigidGPU.h"
 150 #include "TwoStepNPTRigidGPU.h"
 151 #include "TwoStepBDNVTRigidGPU.h"
 152 #include "NeighborListGPU.h"
 153 #include "NeighborListGPUBinned.h"
 154 #include "CGCMMForceComputeGPU.h"
 155 //#include "ConstExternalFieldDipoleForceComputeGPU.h"
 156 #include "BondTablePotentialGPU.h"
 157 #include "TablePotentialGPU.h"
 158 #include "HarmonicAngleForceComputeGPU.h"
 159 #include "TableAngleForceComputeGPU.h"
 160 #include "HarmonicDihedralForceComputeGPU.h"
 161 #include "TableDihedralForceComputeGPU.h"
 162 #include "HarmonicImproperForceComputeGPU.h"
 163 #include "CGCMMAngleForceComputeGPU.h"
 164 #include "Enforce2DUpdaterGPU.h"
 165 #include "FIREEnergyMinimizerRigidGPU.h"
 166 #include "FIREEnergyMinimizerGPU.h"
 167 #include "SFCPackUpdaterGPU.h"
 168 #include "EAMForceComputeGPU.h"
 169 #include "ConstraintSphereGPU.h"
 170 #include "PotentialPairGPU.h"
 171 #include "PPPMForceComputeGPU.h"
 172 #include "PotentialTersoffGPU.h"
 173 #include "ComputeThermoGPU.h"
 174
 175 #include <cuda_profiler_api.h>
 176 #endif
 177
 178 // include MPI classes
 179 #ifdef ENABLE_MPI
 180 #include "Communicator.h"
 181 #include "DomainDecomposition.h"
 182
 183 #ifdef ENABLE_CUDA
 184 #include "CommunicatorGPU.h"
 185 #endif // ENABLE_CUDA
 186 #endif // ENABLE_MPI
 187
 188 #include "SignalHandler.h"
 189
 190 #include "HOOMDVersion.h"
 191 #include "PathUtils.h"
 192
 193 #include <boost/python.hpp>
 194 #include <boost/python/suite/indexing/vector_indexing_suite.hpp>
 195 #include <boost/filesystem/operations.hpp>
 196 #include <boost/filesystem/convenience.hpp>
 197
 198 using namespace boost::filesystem;
 199 using namespace boost::python;
 200
 201 #include <iostream>
 202 #include <sstream>
 203 using namespace std;
 204
 205 /*! \file hoomd_module.cc
 206     \brief Brings all of the export_* functions together to export the hoomd python module
 207 */
 208
 209 //! Function to export the tersoff parameter type to python
 210 void export_tersoff_params()
 211 {
 212     class_<tersoff_params>("tersoff_params", init<>())
 213         .def_readwrite("cutoff_thickness", &tersoff_params::cutoff_thickness)
 214         .def_readwrite("coeffs", &tersoff_params::coeffs)
 215         .def_readwrite("exp_consts", &tersoff_params::exp_consts)
 216         .def_readwrite("dimer_r", &tersoff_params::dimer_r)
 217         .def_readwrite("tersoff_n", &tersoff_params::tersoff_n)
 218         .def_readwrite("gamman", &tersoff_params::gamman)
 219         .def_readwrite("lambda_cube", &tersoff_params::lambda_cube)
 220         .def_readwrite("ang_consts", &tersoff_params::ang_consts)
 221         .def_readwrite("alpha", &tersoff_params::alpha)
 222         ;
 223
 224     def("make_tersoff_params", &make_tersoff_params);
 225 }
 226
 227 //! Scans for a VMD installation
 228 /*! \returns Full path to the vmd executable
 229     This function is for use by the demos and benchmarks installed with HOOMD.
 230 */
 231 string find_vmd()
 232     {
 233 #ifdef WIN32
 234
 235     // find VMD through the registry
 236     vector<string> reg_paths;
 237     reg_paths.push_back("SOFTWARE\\University of Illinois\\VMD\\1.9.1");
 238     reg_paths.push_back("SOFTWARE\\University of Illinois\\VMD\\1.9.0");
 239     reg_paths.push_back("SOFTWARE\\University of Illinois\\VMD\\1.9");
 240     reg_paths.push_back("SOFTWARE\\University of Illinois\\VMD\\1.8.7");
 241     reg_paths.push_back("SOFTWARE\\University of Illinois\\VMD\\1.8.6");
 242
 243     vector<string>::iterator cur_path;
 244     for (cur_path = reg_paths.begin(); cur_path != reg_paths.end(); ++cur_path)
 245         {
 246         string reg_path = *cur_path;
 247
 248         char *value = new char[1024];
 249         DWORD value_size = 1024;
 250         HKEY vmd_root_key;
 251         LONG err_code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, reg_path.c_str(), 0, KEY_READ | KEY_WOW64_32KEY, &vmd_root_key);
 252         if (err_code == ERROR_SUCCESS)
 253             {
 254             err_code = RegQueryValueEx(vmd_root_key, "VMDDIR", NULL, NULL, (LPBYTE)value, &value_size);
 255             // see if it installed where the reg key says so
 256             if (err_code == ERROR_SUCCESS)
 257                 {
 258                 path install_dir = path(string(value));
 259                 if (exists(install_dir / "vmd.exe"))
 260                     return (install_dir / "vmd.exe").string();
 261                 }
 262             }
 263
 264         err_code = RegOpenKeyEx(HKEY_LOCAL_MACHINE, reg_path.c_str(), 0, KEY_READ, &vmd_root_key);
 265         if (err_code == ERROR_SUCCESS)
 266             {
 267             err_code = RegQueryValueEx(vmd_root_key, "VMDDIR", NULL, NULL, (LPBYTE)value, &value_size);
 268             // see if it installed where the reg key says so
 269             if (err_code == ERROR_SUCCESS)
 270                 {
 271                 path install_dir = path(string(value));
 272                 if (exists(install_dir / "vmd.exe"))
 273                     return (install_dir / "vmd.exe").string();
 274                 }
 275             }
 276
 277         delete[] value;
 278         }
 279
 280 #else
 281     // check some likely locations
 282     if (exists("/usr/bin/vmd"))
 283         return "/usr/bin/vmd";
 284     if (exists("/usr/local/bin/vmd"))
 285         return "/usr/local/bin/vmd";
 286     if (exists("/opt/vmd/bin/vmd"))
 287         return "/opt/vmd/bin/vmd";
 288     if (exists(path("/Applications/VMD 1.9.app/Contents/Resources/VMD.app/Contents/MacOS/VMD")))
 289         return("/Applications/VMD 1.9.app/Contents/Resources/VMD.app/Contents/MacOS/VMD");
 290     if (exists(path("/Applications/VMD 1.8.7.app/Contents/Resources/VMD.app/Contents/MacOS/VMD")))
 291         return("/Applications/VMD 1.8.7.app/Contents/Resources/VMD.app/Contents/MacOS/VMD");
 292     if (exists(path("/Applications/VMD 1.8.6.app/Contents/Resources/VMD.app/Contents/MacOS/VMD")))
 293         return("/Applications/VMD 1.8.6.app/Contents/Resources/VMD.app/Contents/MacOS/VMD");
 294 #endif
 295
 296     // return an empty string if we didn't find it
 297     return "";
 298     }
 299
 300 //! Method for getting the current version of HOOMD
 301 /*! \returns Current HOOMD version identification string
 302 */
 303 string get_hoomd_version()
 304     {
 305     ostringstream ver;
 306     // always outputting main version number: #402
 307     ver << "HOOMD-blue " << HOOMD_VERSION << endl;
 308
 309     return ver.str();
 310     }
 311
 312 //! Layer for omp_get_num_procs()
 313 int get_num_procs()
 314     {
 315     return 1;
 316     }
 317
 318 //! Get the hoomd version as a tuple
 319 object get_hoomd_version_tuple()
 320     {
 321     return make_tuple(HOOMD_VERSION_MAJOR, HOOMD_VERSION_MINOR, HOOMD_VERSION_PATCH);
 322     }
 323
 324 //! Get the CUDA version as a tuple
 325 object get_cuda_version_tuple()
 326     {
 327     #ifdef ENABLE_CUDA
 328     int major = CUDA_VERSION / 1000;
 329     int minor = CUDA_VERSION / 10 % 100;
 330     return make_tuple(major, minor);
 331     #else
 332     return make_tuple(0,0);
 333     #endif
 334     }
 335
 336 //! Get the compiler version
 337 string get_compiler_version()
 338     {
 339     #ifdef __GNUC__
 340     ostringstream o;
 341     o << "gcc " << __GNUC__ << "." << __GNUC_MINOR__ << "." <<  __GNUC_PATCHLEVEL__;
 342     return o.str();
 343     #else
 344     return string("unknown");
 345     #endif
 346     }
 347
 348 //! Determine availability of MPI support
 349 bool is_MPI_available()
 350    {
 351    return
 352 #ifdef ENABLE_MPI
 353        true;
 354 #else
 355        false;
 356 #endif
 357     }
 358
 359 //! Start the CUDA profiler
 360 void cuda_profile_start()
 361     {
 362     #ifdef ENABLE_CUDA
 363     cudaDeviceSynchronize();
 364     cudaProfilerStart();
 365     #endif
 366     }
 367
 368 //! Stop the CUDA profiler
 369 void cuda_profile_stop()
 370     {
 371     #ifdef ENABLE_CUDA
 372     cudaDeviceSynchronize();
 373     cudaProfilerStop();
 374     #endif
 375     }
 376
 377 #ifdef ENABLE_MPI
 378 //! Environment variables needed for setting up MPI
 379 char env_enable_mpi_cuda[] = "MV2_USE_CUDA=1";
 380
 381 //! Initialize the MPI environment
 382 void initialize_mpi()
 383     {
 384     #ifdef ENABLE_MPI_CUDA
 385     // if we are using an MPI-CUDA implementation, enable this feature
 386     // before the MPI_Init
 387     putenv(env_enable_mpi_cuda);
 388     #endif
 389
 390     // initalize MPI
 391     MPI_Init(0, (char ***) NULL);
 392     }
 393
 394 //! Finalize MPI environment
 395 void finalize_mpi()
 396     {
 397     MPI_Finalize();
 398     }
 399 #endif
 400
 401 //! Abort MPI runs
 402 void abort_mpi(boost::shared_ptr<ExecutionConfiguration> exec_conf)
 403     {
 404     #ifdef ENABLE_MPI
 405     if (exec_conf->getNRanksGlobal() > 1)
 406         {
 407         MPI_Abort(exec_conf->getMPICommunicator(), MPI_ERR_OTHER);
 408         }
 409     #endif
 410     }
 411
 412 //! Create the python module
 413 /*! each class setup their own python exports in a function export_ClassName
 414     create the hoomd python module and define the exports here.
 415 */
 416 BOOST_PYTHON_MODULE(hoomd)
 417     {
 418     #ifdef ENABLE_MPI
 419     // initialize MPI early
 420     initialize_mpi();
 421
 422     // register clean-up function
 423     Py_AtExit(finalize_mpi);
 424     #endif
 425
 426     def("abort_mpi", abort_mpi);
 427
 428     // write out the version information on the module import
 429     output_version_info(false);
 430     def("find_vmd", &find_vmd);
 431     def("get_hoomd_version", &get_hoomd_version);
 432
 433     def("get_num_procs", &get_num_procs);
 434     scope().attr("__version__") = get_hoomd_version_tuple();
 435     scope().attr("__git_sha1__") = HOOMD_GIT_SHA1;
 436     scope().attr("__git_refspec__") = HOOMD_GIT_REFSPEC;
 437     scope().attr("__cuda_version__") = get_cuda_version_tuple();
 438     scope().attr("__compiler_version__") = get_compiler_version();
 439
 440     def("is_MPI_available", &is_MPI_available);
 441
 442     def("cuda_profile_start", &cuda_profile_start);
 443     def("cuda_profile_stop", &cuda_profile_stop);
 444
 445     // data structures
 446     class_<std::vector<int> >("std_vector_int")
 447     .def(vector_indexing_suite<std::vector<int> >());
 448
 449     class_<std::vector<Scalar3> >("std_vector_scalar3")
 450     .def(vector_indexing_suite<std::vector<Scalar3> >());
 451
 452     InstallSIGINTHandler();
 453
 454     // utils
 455     export_hoomd_math_functions();
 456     export_ClockSource();
 457     export_Profiler();
 458
 459     // data structures
 460     export_BoxDim();
 461     export_ParticleData();
 462     export_SnapshotParticleData();
 463     export_RigidData();
 464     export_SnapshotRigidData();
 465     export_ExecutionConfiguration();
 466     export_SystemDefinition();
 467     export_SnapshotSystemData();
 468     export_BondedGroupData<BondData,Bond>("BondData","BondDataSnapshot");
 469     export_BondedGroupData<AngleData,Angle>("AngleData","AngleDataSnapshot");
 470     export_BondedGroupData<DihedralData,Dihedral>("DihedralData","DihedralDataSnapshot");
 471     export_BondedGroupData<ImproperData,Dihedral>("ImproperData","ImproperDataSnapshot",false);
 472
 473     // initializers
 474     export_RandomInitializer();
 475     export_RandomInitializerWithWalls();
 476     export_SimpleCubicInitializer();
 477     export_HOOMDInitializer();
 478     export_HOOMDBinaryInitializer();
 479     export_RandomGenerator();
 480
 481     // computes
 482     export_Compute();
 483     export_CellList();
 484     export_ForceCompute();
 485     export_ForceConstraint();
 486     export_ConstForceCompute();
 487     export_ConstExternalFieldDipoleForceCompute();
 488     export_HarmonicAngleForceCompute();
 489     export_TableAngleForceCompute();
 490     export_HarmonicDihedralForceCompute();
 491     export_TableDihedralForceCompute();
 492     export_HarmonicImproperForceCompute();
 493     export_CGCMMAngleForceCompute();
 494     export_TablePotential();
 495     export_BondTablePotential();
 496     export_CGCMMForceCompute();
 497     export_PotentialPair<PotentialPairLJ>("PotentialPairLJ");
 498     export_PotentialPair<PotentialPairGauss>("PotentialPairGauss");
 499     export_PotentialPair<PotentialPairSLJ>("PotentialPairSLJ");
 500     export_PotentialPair<PotentialPairYukawa>("PotentialPairYukawa");
 501     export_PotentialPair<PotentialPairEwald>("PotentialPairEwald");
 502     export_PotentialPair<PotentialPairMorse>("PotentialPairMorse");
 503     export_PotentialPair<PotentialPairDPD> ("PotentialPairDPD");
 504     export_PotentialPair<PotentialPairMoliere> ("PotentialPairMoliere");
 505     export_PotentialPair<PotentialPairZBL> ("PotentialPairZBL");
 506     export_PotentialTersoff<PotentialTripletTersoff> ("PotentialTersoff");
 507     export_tersoff_params();
 508     export_PotentialPair<PotentialPairForceShiftedLJ>("PotentialPairForceShiftedLJ");
 509     export_PotentialPairDPDThermo<PotentialPairDPDThermoDPD, PotentialPairDPD>("PotentialPairDPDThermoDPD");
 510     export_PotentialPair<PotentialPairDPDLJ> ("PotentialPairDPDLJ");
 511     export_PotentialPairDPDThermo<PotentialPairDPDLJThermoDPD, PotentialPairDPDLJ>("PotentialPairDPDLJThermoDPD");
 512     export_PotentialBond<PotentialBondHarmonic>("PotentialBondHarmonic");
 513     export_PotentialBond<PotentialBondFENE>("PotentialBondFENE");
 514     export_EAMForceCompute();
 515     export_LJWallForceCompute();
 516     export_ComputeThermo();
 517     export_NeighborList();
 518     export_NeighborListBinned();
 519     export_ConstraintSphere();
 520     export_PPPMForceCompute();
 521     export_PotentialExternal<PotentialExternalPeriodic>("PotentialExternalPeriodic");
 522 #ifdef ENABLE_CUDA
 523     export_CellListGPU();
 524     export_NeighborListGPU();
 525     export_NeighborListGPUBinned();
 526     export_CGCMMForceComputeGPU();
 527     export_PotentialPairGPU<PotentialPairLJGPU, PotentialPairLJ>("PotentialPairLJGPU");
 528     export_PotentialPairGPU<PotentialPairGaussGPU, PotentialPairGauss>("PotentialPairGaussGPU");
 529     export_PotentialPairGPU<PotentialPairSLJGPU, PotentialPairSLJ>("PotentialPairSLJGPU");
 530     export_PotentialPairGPU<PotentialPairYukawaGPU, PotentialPairYukawa>("PotentialPairYukawaGPU");
 531     export_PotentialPairGPU<PotentialPairEwaldGPU, PotentialPairEwald>("PotentialPairEwaldGPU");
 532     export_PotentialPairGPU<PotentialPairMorseGPU, PotentialPairMorse>("PotentialPairMorseGPU");
 533     export_PotentialPairGPU<PotentialPairDPDGPU, PotentialPairDPD> ("PotentialPairDPDGPU");
 534     export_PotentialPairGPU<PotentialPairMoliereGPU, PotentialPairMoliere> ("PotentialPairMoliereGPU");
 535     export_PotentialPairGPU<PotentialPairZBLGPU, PotentialPairZBL> ("PotentialPairZBLGPU");
 536     export_PotentialTersoffGPU<PotentialTripletTersoffGPU, PotentialTripletTersoff> ("PotentialTersoffGPU");
 537     export_PotentialPairGPU<PotentialPairForceShiftedLJGPU, PotentialPairForceShiftedLJ>("PotentialPairForceShiftedLJGPU");
 538     export_PotentialPairDPDThermoGPU<PotentialPairDPDThermoDPDGPU, PotentialPairDPDThermoDPD >("PotentialPairDPDThermoDPDGPU");
 539     export_PotentialPairGPU<PotentialPairDPDLJGPU, PotentialPairDPDLJ> ("PotentialPairDPDLJGPU");
 540     export_PotentialPairDPDThermoGPU<PotentialPairDPDLJThermoDPDGPU, PotentialPairDPDLJThermoDPD >("PotentialPairDPDLJThermoDPDGPU");
 541     export_PotentialBondGPU<PotentialBondHarmonicGPU, PotentialBondHarmonic>("PotentialBondHarmonicGPU");
 542     export_PotentialBondGPU<PotentialBondFENEGPU, PotentialBondFENE>("PotentialBondFENEGPU");
 543     export_BondTablePotentialGPU();
 544     export_TablePotentialGPU();
 545     export_EAMForceComputeGPU();
 546     export_HarmonicAngleForceComputeGPU();
 547     export_TableAngleForceComputeGPU();
 548     export_HarmonicDihedralForceComputeGPU();
 549     export_TableDihedralForceComputeGPU();
 550     export_HarmonicImproperForceComputeGPU();
 551     export_CGCMMAngleForceComputeGPU();
 552     export_ComputeThermoGPU();
 553     export_ConstraintSphereGPU();
 554 //    export_ConstExternalFieldDipoleForceComputeGPU();
 555     export_PPPMForceComputeGPU();
 556     export_PotentialExternalGPU<PotentialExternalPeriodicGPU, PotentialExternalPeriodic>("PotentialExternalPeriodicGPU");
 557 #endif
 558
 559     // analyzers
 560     export_Analyzer();
 561     export_IMDInterface();
 562     export_HOOMDDumpWriter();
 563     export_HOOMDBinaryDumpWriter();
 564     export_PDBDumpWriter();
 565     export_DCDDumpWriter();
 566     export_MOL2DumpWriter();
 567     export_Logger();
 568     export_MSDAnalyzer();
 569     export_ParticleGroup();
 570
 571     // updaters
 572     export_Updater();
 573     export_Integrator();
 574     export_IntegratorTwoStep();
 575     export_IntegrationMethodTwoStep();
 576     export_TempRescaleUpdater();
 577     export_ZeroMomentumUpdater();
 578     export_SFCPackUpdater();
 579     export_BoxResizeUpdater();
 580     export_TwoStepNVE();
 581     export_TwoStepNVT();
 582     export_TwoStepNVTMTK();
 583     export_TwoStepBDNVT();
 584     export_TwoStepNPTMTK();
 585     export_Berendsen();
 586     export_TwoStepNVERigid();
 587     export_TwoStepNVTRigid();
 588     export_TwoStepNPHRigid();
 589     export_TwoStepNPTRigid();
 590     export_TwoStepBDNVTRigid();
 591     export_Enforce2DUpdater();
 592     export_FIREEnergyMinimizer();
 593     export_FIREEnergyMinimizerRigid();
 594 #ifdef ENABLE_CUDA
 595     export_SFCPackUpdaterGPU();
 596     export_TwoStepNVEGPU();
 597     export_TwoStepNVTGPU();
 598     export_TwoStepNVTMTKGPU();
 599     export_TwoStepBDNVTGPU();
 600     export_TwoStepNPTMTKGPU();
 601     export_BerendsenGPU();
 602     export_TwoStepNVERigidGPU();
 603     export_TwoStepNVTRigidGPU();
 604     export_TwoStepNPHRigidGPU();
 605     export_TwoStepNPTRigidGPU();
 606     export_TwoStepBDNVTRigidGPU();
 607     export_Enforce2DUpdaterGPU();
 608     export_FIREEnergyMinimizerGPU();
 609     export_FIREEnergyMinimizerRigidGPU();
 610 #endif
 611
 612 #ifdef ENABLE_MPI
 613     export_Communicator();
 614     export_DomainDecomposition();
 615 #ifdef ENABLE_CUDA
 616     export_CommunicatorGPU();
 617 #endif // ENABLE_CUDA
 618 #endif // ENABLE_MPI
 619
 620     // system
 621     export_System();
 622
 623     // variant
 624     export_Variant();
 625
 626     // messenger
 627     export_Messenger();
 628     }
 629
 630 #ifdef WIN32
 631 #pragma warning( pop )
 632 #endif
 633