Fix issues compiling envelope module

Compiled and able to import from orbit.core.envelope

Author: austin-hoover

src/core/envelope_init.cc

@@ -1,4 +1,4 @@
 #include "wrap_envelope.hh"
 PyMODINIT_FUNC PyInit_envelope(void) {
-    return initenvelope();
+    return wrap_envelope::initenvelope();
 }

src/envelope/EnvSolverDanilov20.cc

@@ -1,36 +1,36 @@
-#include "Danilov20EnvelopeSolver.hh"
+#include "EnvSolverDanilov20.hh"
 
-Danilov20EnvelopeSolver::Danilov20EnvelopeSolver(double perveance, double emittanceX, double emittanceY) : CppPyWrapper(NULL) {
+EnvSolverDanilov20::EnvSolverDanilov20(double perveance, double emittanceX, double emittanceY) : CppPyWrapper(NULL) {
   Q = perveance;
   epsX = emittanceX;
   epsY = emittanceY;
 }
 
-void Danilov20EnvelopeSolver::setPerveance(double perveance) {
+void EnvSolverDanilov20::setPerveance(double perveance) {
   Q = perveance;
 }
 
-void Danilov20EnvelopeSolver::setEmittanceX(double emittanceX) {
+void EnvSolverDanilov20::setEmittanceX(double emittanceX) {
   epsX = emittanceX;
 }
 
-void Danilov20EnvelopeSolver::setEmittanceY(double emittanceY) {
+void EnvSolverDanilov20::setEmittanceY(double emittanceY) {
   epsY = emittanceY;
 }
 
-double Danilov20EnvelopeSolver::getPerveance() {
+double EnvSolverDanilov20::getPerveance() {
   return Q;
 }
 
-double Danilov20EnvelopeSolver::getEmittanceX() {
+double EnvSolverDanilov20::getEmittanceX() {
   return epsX;
 }
 
-double Danilov20EnvelopeSolver::getEmittanceY() {
+double EnvSolverDanilov20::getEmittanceY() {
   return epsY;
 }
 
-void Danilov20EnvelopeSolver::trackBunch(Bunch *bunch, double length) {
+void EnvSolverDanilov20::trackBunch(Bunch *bunch, double length) {
     // Track envelope
     double cx = bunch->x(0);
     double cy = bunch->y(0);

src/envelope/EnvSolverDanilov20.hh

@@ -1,5 +1,5 @@
-#ifndef DANILOV_20_ENVELOPE_SOLVER_H
-#define DANILOV_20_ENVELOPE_SOLVER_H
+#ifndef ENV_SOLVER_DANILOV_20_H
+#define ENV_SOLVER_DANILOV_20_H
 
 #include "Bunch.hh"
 #include "CppPyWrapper.hh"
@@ -14,9 +14,9 @@ using namespace std;
  envelope parameters {a, b}, which are used to apply space charge kicks to the
  other particles in the bunch.
  */
-class Danilov20EnvelopeSolver : public OrbitUtils::CppPyWrapper {
+class EnvSolverDanilov20 : public OrbitUtils::CppPyWrapper {
 public:
-  Danilov20EnvelopeSolver(double perveance, double emittanceX, double emittanceY);
+  EnvSolverDanilov20(double perveance, double emittanceX, double emittanceY);
   void trackBunch(Bunch *bunch, double length);
   void setPerveance(double perveance);
   void setEmittanceX(double emittanceX);

src/envelope/EnvSolverDanilov22.cc

@@ -1,18 +1,18 @@
-#include "Danilov22EnvelopeSolver.hh"
+#include "EnvSolverDanilov22.hh"
 
-Danilov22EnvelopeSolver::Danilov22EnvelopeSolver(double perveance) : CppPyWrapper(NULL) {
+EnvSolverDanilov22::EnvSolverDanilov22(double perveance) : CppPyWrapper(NULL) {
   Q = perveance;
 }
 
-void Danilov22EnvelopeSolver::setPerveance(double perveance) {
+void EnvSolverDanilov22::setPerveance(double perveance) {
   Q = perveance; 
 }
 
-double Danilov22EnvelopeSolver::getPerveance() {
+double EnvSolverDanilov22::getPerveance() {
   return Q;
 }
 
-void Danilov22EnvelopeSolver::trackBunch(Bunch *bunch, double length) {
+void EnvSolverDanilov22::trackBunch(Bunch *bunch, double length) {
   // Compute ellipse size and orientation.
   double a = bunch->x(0);
   double b = bunch->x(1);

src/envelope/EnvSolverDanilov22.hh

@@ -1,5 +1,5 @@
-#ifndef DANILOV_22_ENVELOPE_SOLVER_H
-#define DANILOV_22_ENVELOPE_SOLVER_H
+#ifndef ENV_SOLVER_DANILOV_22_H
+#define ENV_SOLVER_DANILOV_22_H
 
 #include "Bunch.hh"
 #include "CppPyWrapper.hh"
@@ -21,15 +21,15 @@ using namespace std;
  dependent two dimensional and three dimensional space charge distributions with
  linear force", PPRAB 6, 74–85 (2003).
 */
-class Danilov22EnvelopeSolver : public OrbitUtils::CppPyWrapper {
+class EnvSolverDanilov22 : public OrbitUtils::CppPyWrapper {
 public:
-  Danilov22EnvelopeSolver(double perveanceQ);
+  EnvSolverDanilov22(double perveanceQ);
   void trackBunch(Bunch *bunch, double length);
   void setPerveance(double perveance);
   double getPerveance();
 
 private:
-  double Q;   // beam perveance
+  double Q;  // beam perveance
 };
 
 #endif

src/envelope/wrap_env_solver_danilov_20.cc

@@ -3,150 +3,150 @@
 #include "orbit_mpi.hh"
 #include "pyORBIT_Object.hh"
 
-#include "Danilov20EnvelopeSolver.hh"
-#include "wrap_danilov_20_envelope_solver.hh"
+#include "EnvSolverDanilov20.hh"
 #include "wrap_bunch.hh"
 #include "wrap_envelope.hh"
+#include "wrap_env_solver_danilov_20.hh"
 
 namespace wrap_envelope {
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-// Constructor for Python class wrapping Danilov20EnvelopeSolver instance.
+// Constructor for Python class wrapping EnvSolverDanilov20 instance.
 // It never will be called directly.
-static PyObject *Danilov20EnvelopeSolver_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
+static PyObject *EnvSolverDanilov20_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
   pyORBIT_Object *self;
   self = (pyORBIT_Object *)type->tp_alloc(type, 0);
   self->cpp_obj = NULL;
   return (PyObject *)self;
 }
 
-// Initialization of Python Danilov20EnvelopeSolver class.
+// Initialization of Python EnvSolverDanilov20 class.
 // This is implementation of the __init__ method.
-static int Danilov20EnvelopeSolver_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) {
+static int EnvSolverDanilov20_init(pyORBIT_Object *self, PyObject *args, PyObject *kwds) {
   double perveance = 0.0;
   double eps_x = 1.0;
   double eps_y = 1.0;
-  self->cpp_obj = new Danilov20EnvelopeSolver(perveance, eps_x, eps_y);
-  ((Danilov20EnvelopeSolver *)self->cpp_obj)->setPyWrapper((PyObject *)self);
+  self->cpp_obj = new EnvSolverDanilov20(perveance, eps_x, eps_y);
+  ((EnvSolverDanilov20 *)self->cpp_obj)->setPyWrapper((PyObject *)self);
   return 0;
 }
 
 // Method: trackBunch(Bunch* bunch, double length)
-static PyObject *Danilov20EnvelopeSolver_trackBunch(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
+static PyObject *EnvSolverDanilov20_trackBunch(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
   PyObject *pyBunch;
   double length;
   if (!PyArg_ParseTuple(args, "Od:trackBunch", &pyBunch, &length)) {
-    ORBIT_MPI_Finalize("PyDanilov20EnvelopeSolver - trackBunch(Bunch* bunch, double length) - parameters are needed.");
+    ORBIT_MPI_Finalize("PyEnvSolverDanilov20 - trackBunch(Bunch* bunch, double length) - parameters are needed.");
   }
   PyObject *pyORBIT_Bunch_Type = wrap_orbit_bunch::getBunchType("Bunch");
   if (!PyObject_IsInstance(pyBunch, pyORBIT_Bunch_Type)) {
-    ORBIT_MPI_Finalize("PyDanilov20EnvelopeSolver - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch.");
+    ORBIT_MPI_Finalize("PyEnvSolverDanilov20 - trackBunch(Bunch* bunch, double length) - first parameter should be Bunch.");
   }
   Bunch *cpp_bunch = (Bunch *)((pyORBIT_Object *)pyBunch)->cpp_obj;
-  cpp_Danilov20EnvelopeSolver->trackBunch(cpp_bunch, length);
+  cpp_EnvSolverDanilov20->trackBunch(cpp_bunch, length);
   Py_INCREF(Py_None);
   return Py_None;
 }
 
 // Method: setPerveance(double perveance)
-static PyObject *Danilov20EnvelopeSolver_setPerveance(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
+static PyObject *EnvSolverDanilov20_setPerveance(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
   double perveance;
   if (!PyArg_ParseTuple(args, "d:setPerveance", &perveance)) {
-    ORBIT_MPI_Finalize("PyDanilov20EnvelopeSolver - setPerveance(double perveance) - parameters are needed.");
+    ORBIT_MPI_Finalize("PyEnvSolverDanilov20 - setPerveance(double perveance) - parameters are needed.");
   }
-  cpp_Danilov20EnvelopeSolver->setPerveance(perveance);
+  cpp_EnvSolverDanilov20->setPerveance(perveance);
   Py_INCREF(Py_None);
   return Py_None;
 }
 
 // Method: setEmittanceX(double eps_x)
-static PyObject *Danilov20EnvelopeSolver_setEmittanceX(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
-  double emittanceX;
-  if (!PyArg_ParseTuple(args, "d:setEmittanceX", &emittanceX)) {
-    ORBIT_MPI_Finalize("PyDanilov20EnvelopeSolver - setEmittanceX(double emittanceX) - parameters are needed.");
+static PyObject *EnvSolverDanilov20_setEmittanceX(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
+  double eps_x;
+  if (!PyArg_ParseTuple(args, "d:setEmittanceX", &eps_x)) {
+    ORBIT_MPI_Finalize("PyEnvSolverDanilov20 - setEmittanceX(double eps_x) - parameters are needed.");
   }
-  cpp_Danilov20EnvelopeSolver->setEmittanceX(emittanceX);
+  cpp_EnvSolverDanilov20->setEmittanceX(eps_x);
   Py_INCREF(Py_None);
   return Py_None;
 }
 
 // Method: setEmittanceY(double eps_y)
-static PyObject *Danilov20EnvelopeSolver_setEmittanceY(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
-  double emittanceY;
-  if (!PyArg_ParseTuple(args, "d:setEmittanceY", &emittanceY)) {
-    ORBIT_MPI_Finalize("PyDanilov20EnvelopeSolver - setEmittanceY(double emittanceY) - parameters are needed.");
+static PyObject *EnvSolverDanilov20_setEmittanceY(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
+  double eps_y;
+  if (!PyArg_ParseTuple(args, "d:setEmittanceY", &eps_y)) {
+    ORBIT_MPI_Finalize("PyEnvSolverDanilov20 - setEmittanceY(double eps_y) - parameters are needed.");
   }
-  cpp_Danilov20EnvelopeSolver->setEmittanceY(emittanceY);
+  cpp_EnvSolverDanilov20->setEmittanceY(eps_y);
   Py_INCREF(Py_None);
   return Py_None;
 }
 
 // Method: getPerveance()
-static PyObject *Danilov20EnvelopeSolver_getPerveance(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
-  double perveance = cpp_Danilov20EnvelopeSolver->getPerveance();
+static PyObject *EnvSolverDanilov20_getPerveance(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
+  double perveance = cpp_EnvSolverDanilov20->getPerveance();
   return Py_BuildValue("d", perveance);
 }
 
 // Method: getEmittanceX()
-static PyObject *Danilov20EnvelopeSolver_getEmittanceX(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
-  double emittanceX = cpp_Danilov20EnvelopeSolver->getEmittanceX();
-  return Py_BuildValue("d", emittanceX);
+static PyObject *EnvSolverDanilov20_getEmittanceX(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
+  double eps_x = cpp_EnvSolverDanilov20->getEmittanceX();
+  return Py_BuildValue("d", eps_x);
 }
 
 // Method: getEmittanceY()
-static PyObject *Danilov20EnvelopeSolver_getEmittanceY(PyObject *self, PyObject *args) {
-  pyORBIT_Object *pyDanilov20EnvelopeSolver = (pyORBIT_Object *)self;
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)pyDanilov20EnvelopeSolver->cpp_obj;
-  double emittanceY = cpp_Danilov20EnvelopeSolver->getEmittanceY();
-  return Py_BuildValue("d", emittanceY);
+static PyObject *EnvSolverDanilov20_getEmittanceY(PyObject *self, PyObject *args) {
+  pyORBIT_Object *pyEnvSolverDanilov20 = (pyORBIT_Object *)self;
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)pyEnvSolverDanilov20->cpp_obj;
+  double eps_y = cpp_EnvSolverDanilov20->getEmittanceY();
+  return Py_BuildValue("d", eps_y);
 }
 
-// Destructor for python Danilov20EnvelopeSolver class (__del__ method)
-static void Danilov20EnvelopeSolver_del(pyORBIT_Object *self) {
-  Danilov20EnvelopeSolver *cpp_Danilov20EnvelopeSolver = (Danilov20EnvelopeSolver *)self->cpp_obj;
-  delete cpp_Danilov20EnvelopeSolver;
+// Destructor for python EnvSolverDanilov20 class (__del__ method)
+static void EnvSolverDanilov20_del(pyORBIT_Object *self) {
+  EnvSolverDanilov20 *cpp_EnvSolverDanilov20 = (EnvSolverDanilov20 *)self->cpp_obj;
+  delete cpp_EnvSolverDanilov20;
   self->ob_base.ob_type->tp_free((PyObject *)self);
 }
 
-// Definition of Python Danilov20EnvelopeSolver wrapper class methods.
+// Definition of Python EnvSolverDanilov20 wrapper class methods.
 // They will be available from the Python level.
-static PyMethodDef Danilov20EnvelopeSolverClassMethods[] = {
-  {"getEmittanceX", Danilov20EnvelopeSolver_getEmittanceX, METH_VARARGS, "Get emittance (x)."},
-  {"getEmittanceY", Danilov20EnvelopeSolver_getEmittanceY, METH_VARARGS, "Get emittance (y)."},
-  {"getPerveance", Danilov20EnvelopeSolver_getPerveance, METH_VARARGS, "Get space charge perveance."},
-  {"setEmittanceX", Danilov20EnvelopeSolver_setEmittanceX, METH_VARARGS, "Set emittance (x)."},
-  {"setEmittanceY", Danilov20EnvelopeSolver_setEmittanceY, METH_VARARGS, "Set emittance (y)."},
-  {"setPerveance", Danilov20EnvelopeSolver_setPerveance, METH_VARARGS, "Set space charge perveance."},
-  {"trackBunch", Danilov20EnvelopeSolver_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."},
+static PyMethodDef EnvSolverDanilov20ClassMethods[] = {
+  {"getEmittanceX", EnvSolverDanilov20_getEmittanceX, METH_VARARGS, "Get emittance (x)."},
+  {"getEmittanceY", EnvSolverDanilov20_getEmittanceY, METH_VARARGS, "Get emittance (y)."},
+  {"getPerveance", EnvSolverDanilov20_getPerveance, METH_VARARGS, "Get space charge perveance."},
+  {"setEmittanceX", EnvSolverDanilov20_setEmittanceX, METH_VARARGS, "Set emittance (x)."},
+  {"setEmittanceY", EnvSolverDanilov20_setEmittanceY, METH_VARARGS, "Set emittance (y)."},
+  {"setPerveance", EnvSolverDanilov20_setPerveance, METH_VARARGS, "Set space charge perveance."},
+  {"trackBunch", EnvSolverDanilov20_trackBunch, METH_VARARGS, "Apply space charge kick to beam envelope."},
   {NULL}
 };
 
-// Definition of Python Danilov20EnvelopeSolver wrapper class members.
+// Definition of Python EnvSolverDanilov20 wrapper class members.
 // They will be available from the Python level.
-static PyMemberDef Danilov20EnvelopeSolverClassMembers[] = {
+static PyMemberDef EnvSolverDanilov20ClassMembers[] = {
     {NULL}};
 
-// New python Danilov20EnvelopeSolver wrapper type definition.
-static PyTypeObject pyORBIT_Danilov20EnvelopeSolver_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0) "Danilov20EnvelopeSolver", /*tp_name*/
+// New python EnvSolverDanilov20 wrapper type definition.
+static PyTypeObject pyORBIT_EnvSolverDanilov20_Type = {
+    PyVarObject_HEAD_INIT(NULL, 0) "EnvSolverDanilov20", /*tp_name*/
     sizeof(pyORBIT_Object),                                   /*tp_basicsize*/
     0,                                                        /*tp_itemsize*/
-    (destructor)Danilov20EnvelopeSolver_del,                  /*tp_dealloc*/
+    (destructor)EnvSolverDanilov20_del,                  /*tp_dealloc*/
     0,                                                        /*tp_print*/
     0,                                                        /*tp_getattr*/
     0,                                                        /*tp_setattr*/
@@ -162,37 +162,37 @@ static PyTypeObject pyORBIT_Danilov20EnvelopeSolver_Type = {
     0,                                                        /*tp_setattro*/
     0,                                                        /*tp_as_buffer*/
     Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,                 /*tp_flags*/
-    "The Danilov20EnvelopeSolver python wrapper",             /* tp_doc */
+    "The EnvSolverDanilov20 python wrapper",             /* tp_doc */
     0,                                                        /* tp_traverse */
     0,                                                        /* tp_clear */
     0,                                                        /* tp_richcompare */
     0,                                                        /* tp_weaklistoffset */
     0,                                                        /* tp_iter */
     0,                                                        /* tp_iternext */
-    Danilov20EnvelopeSolverClassMethods,                      /* tp_methods */
-    Danilov20EnvelopeSolverClassMembers,                      /* tp_members */
+    EnvSolverDanilov20ClassMethods,                      /* tp_methods */
+    EnvSolverDanilov20ClassMembers,                      /* tp_members */
     0,                                                        /* tp_getset */
     0,                                                        /* tp_base */
     0,                                                        /* tp_dict */
     0,                                                        /* tp_descr_get */
     0,                                                        /* tp_descr_set */
     0,                                                        /* tp_dictoffset */
-    (initproc)Danilov20EnvelopeSolver_init,                   /* tp_init */
+    (initproc)EnvSolverDanilov20_init,                   /* tp_init */
     0,                                                        /* tp_alloc */
-    Danilov20EnvelopeSolver_new,                              /* tp_new */
+    EnvSolverDanilov20_new,                              /* tp_new */
 };
 
-// Initialization function of the pyDanilov20EnvelopeSolver class
-void initDanilov20EnvelopeSolver(PyObject *module) {
-  if (PyType_Ready(&pyORBIT_Danilov20EnvelopeSolver_Type) < 0)
+// Initialization function of the pyEnvSolverDanilov20 class
+void initEnvSolverDanilov20(PyObject *module) {
+  if (PyType_Ready(&pyORBIT_EnvSolverDanilov20_Type) < 0)
     return;
-  Py_INCREF(&pyORBIT_Danilov20EnvelopeSolver_Type);
-  PyModule_AddObject(module, "Danilov20EnvelopeSolver", (PyObject *)&pyORBIT_Danilov20EnvelopeSolver_Type);
+  Py_INCREF(&pyORBIT_EnvSolverDanilov20_Type);
+  PyModule_AddObject(module, "EnvSolverDanilov20", (PyObject *)&pyORBIT_EnvSolverDanilov20_Type);
 }
 
 #ifdef __cplusplus
 }
 #endif
 
-// end of namespace wrap_danilov_envelope
-} // namespace wrap_danilov_envelope
+// end of namespace wrap_envelope
+} // namespace wrap_envelope