// * GCHMCIntegrator Constructor * //
GCHMCIntegrator::GCHMCIntegrator(PyObject *universe, std::string ligdir, std::string gaff_fn)
{
std::cout<<"GCHMCIntegrator instance created 20160826"<<std::endl;
import_array();
temperature = 300.0;
delta_t = 0.0015;
trouble = 0;
this->universe = universe;
PyObject *pyo_universe_spec;
pyo_universe_spec = PyObject_GetAttrString(universe, "_spec");
universe_spec = (PyUniverseSpecObject *)pyo_universe_spec;
PyObject *objectList;
objectList = PyObject_CallMethod(universe, "objectList", NULL);
PyObject *object0 = PyList_GetItem(objectList, 0);
// * Get confarr * //
PyObject *confobj;
PyObject *confarr;
confobj = PyObject_CallMethod(universe, "configuration", NULL);
confarr = PyObject_GetAttrString(confobj, "array");
configuration = (PyArrayObject *)confarr;
vector3 *x;
x = (vector3 *)configuration->data;
p_energy_po = new energy_data;
#if defined(NUMPY)
gradarr = (PyArrayObject *)PyArray_Copy(configuration);
#else
gradarr = (PyArrayObject *)PyArray_FromDims(configuration->nd, configuration->dimensions, PyArray_DOUBLE);
#endif
vector3 *f;
f = (vector3 *)gradarr->data;
for(int i=0; i<configuration->dimensions[0]; i++){
f[i][0] = f[i][1] = f[i][2] = .0;
}
p_energy_po->gradients = (PyObject *)gradarr;
p_energy_po->gradient_fn = NULL;
p_energy_po->force_constants = NULL;
p_energy_po->fc_fn = NULL;
int natoms = configuration->dimensions[0];
int order[natoms+2];
int acceptance;
PyObject *prmtop_order_obj = PyObject_GetAttrString(object0, "prmtop_order");
for(int i=0; i<PyList_Size(prmtop_order_obj); i++){
order[i] = (int)PyInt_AS_LONG( PyObject_GetAttrString(PyList_GetItem((prmtop_order_obj), i), "number") );
}
PyArrayObject *prmtop_order = (PyArrayObject *)prmtop_order_obj;
order[natoms] = 1;
order[natoms+1] = 1945;
acceptance = order[natoms];
int argc = 6;
ligdir += '/';
//gaffdir += '/';
//string gaff_fn = gaffdir + "gaff.dat";
/* Options are:
IC: Internal Coordinates: fully flexible
TD: Torsional Dynamics: only torsions are flexible
RR: Rigid Rings: torsional dynamics with rigid rings
*/
const char *argv[6] = {
"-ligdir", ligdir.c_str(),
"-gaff", gaff_fn.c_str(),
"-ictd", "TD"
};
//+++++++ Simbody PART ++++++++++++
bArgParser parser(argc, argv);
parser.Print();
TARGET_TYPE **indexMap = NULL;
TARGET_TYPE *PrmToAx_po = NULL;
TARGET_TYPE *MMTkToPrm_po = NULL;
std::cout<<"MMTK configuration->dimensions[0]"<<configuration->dimensions[0]<<std::endl<<std::flush;
indexMap = new TARGET_TYPE*[(configuration->dimensions[0])];
int _indexMap[natoms][3];
PrmToAx_po = new TARGET_TYPE[configuration->dimensions[0]];
MMTkToPrm_po = new TARGET_TYPE[configuration->dimensions[0]];
int natoms3 = 3*(configuration->dimensions[0]);
int arrays_cut = 2 + 4*natoms3;
SHMSZ = (
2*sizeof(TARGET_TYPE) + // Counter and flag
natoms3*sizeof(TARGET_TYPE) + // Positions
natoms3*sizeof(TARGET_TYPE) + // Velocities
natoms3*sizeof(TARGET_TYPE) + // indexMap
natoms3*sizeof(TARGET_TYPE) + // Gradients
5*sizeof(TARGET_TYPE) + // ac + 0 -> 4 // step, nosteps, temperature, timestep, trouble
1*sizeof(TARGET_TYPE) + // ac + 5 // potential energy
2*sizeof(TARGET_TYPE) + // ac + 6->7 // DAE step done; Move accepted
1*sizeof(TARGET_TYPE) + // ac + 8 // KE
1*sizeof(TARGET_TYPE) + // ac + 9 // steps_per_trial
1*sizeof(TARGET_TYPE) //+ // ac + 10 // trial
);
shm = new TARGET_TYPE[SHMSZ];
std::cout<<"parser.mol2F "<<parser.mol2F<<std::endl<<std::flush;
std::cout<<"parser.rbF "<<parser.rbF<<std::endl<<std::flush;
std::cout<<"parser.gaffF "<<parser.gaffF<<std::endl<<std::flush;
std::cout<<"parser.frcmodF "<<parser.frcmodF<<std::endl<<std::flush;
std::cout<<"parser.ictdF "<<parser.ictdF<<std::endl<<std::flush;
// LS EU
//(((PyFFEnergyTermObject **)(evaluator)->terms->data)[5])->param[0] = 0.5;
// LS EU
sys = new SymSystem(
parser.mol2F, parser.rbF, parser.gaffF, parser.frcmodF,
parser.ictdF,
PrmToAx_po, MMTkToPrm_po,
evaluator,
p_energy_po,
configuration,
universe_spec,
shm
);
for(int i=0; i<natoms; i++){
_indexMap[i][2] = order[i];
}
// * Memory alloc for convinient arrays * //
coords = new TARGET_TYPE*[sys->mr->natms];
TARGET_TYPE **vels = new TARGET_TYPE*[sys->mr->natms];
TARGET_TYPE **inivels = new TARGET_TYPE*[sys->mr->natms];
TARGET_TYPE **grads = new TARGET_TYPE*[sys->mr->natms];
// * Seed the random number generator * //
srand (time(NULL));
//+++++++ SERVER PART +++++++++
float mysweep = 0;
shm[0] = CNT_START;
int cli;
sweep = 0;
bool system_initialized = false;
int big_loop_i;
shm[1] = CLIENT_FLAG;
int a;
int start, start_1, stop;
int i = natoms*2*3 + 2;
// * Assign convenient pointers for order * /
start = 2 + natoms3 + natoms3;
for(a=0; a<natoms; a++){
indexMap[a] = &(shm[a*3 + start]);
}
// * Assign order in shm[][2] * //
start = 2 + natoms3 + natoms3;
cli = start;
for (a=0; a<natoms; a++){ // Order
cli += 2;
shm[cli++] = order[a];
}
cli = 2;
for (a=0; a<natoms; a++){ // Positions
shm[cli++] = x[a][0]; shm[cli++] = x[a][1]; shm[cli++] = x[a][2];
}
for (a=0; a<natoms; a++){ // Velocities
shm[cli++] = .0; //vels[a][0];//shm[cli++] = v[a][0];
shm[cli++] = .0; //vels[a][1];//shm[cli++] = v[a][1];
shm[cli++] = .0; //vels[a][2];//shm[cli++] = v[a][2];
}
for (a=0; a<natoms; a++){ // Order
cli += 2;
shm[cli++] = order[a];
}
for (a=0; a<natoms; a++){ // Forces
shm[cli++] = .0; shm[cli++] = .0; shm[cli++] = .0;
}
shm[cli++] = big_loop_i; // Step
shm[cli++] = 50.0; //(TARGET_TYPE)nosteps; // Number of steps
shm[cli++] = temperature; // Temeperature
shm[cli++] = delta_t;
shm[cli++] = trouble;
shm[cli++] = p_energy_po->energy;
cli++; // DAE set only by the server
shm[cli] = acceptance + 0.0;
//Set the client flag
shm[1] = CLIENT_FLAG;
shm[arrays_cut + 6] = 13.0; // set DAE to done
// * Assign convenient pointers for coordinates * //
int shm_coords_sup = (natoms3)+2;
int j=-1, k=0;
start = 2;
for(j=0; j<natoms; j++){
coords[j] = &(shm[j*3 + start]);
}
mysweep = shm[0] - CNT_START;
// * Assign convenient pointers for velocities * //
start = 2 + natoms3;
start_1 = start - 1;
stop = 2 + natoms3 + natoms3;
for(j=0; j<natoms; j++){
vels[j] = &(shm[j*3 + start]);
inivels[j] = &(shm[j*3 + start]);
}
// * Assign convenient pointers for gradients * //
start = 2 + natoms3 + natoms3 + natoms3;
start_1 = start - 1;
stop = 2 + natoms3 + natoms3 + natoms3 + natoms3;
for(j=0; j<natoms; j++){
grads[j] = &(shm[j*3 + start]);
}
// * Rewrite indexMap to memory * /
start = 2 + natoms3 + natoms3;
start_1 = start - 1;
stop = 2 + natoms3 + natoms3 + natoms3;
// ************************* /
// * Initialize Simulation * /
// ************************* /
TARGET_TYPE timestep, mytimestep;
mytimestep = shm[arrays_cut + 3];
// * Build bMainResidue and fill indexMap * /
sys->InitSimulation(coords, vels, inivels, indexMap, grads, mytimestep, true);
system_initialized = true;
}
static int
pcap_PcapObject_init(PyObject *p,
PyObject *args,
PyObject *kwds)
{
pcap_PcapObject *self = (pcap_PcapObject *)p;
static char *kwlist[] = {"src", "mode", "snaplen", "linktype", NULL};
char *mode = NULL;
_uint32_t snaplen = 65535;
_uint32_t linktype = 1;
PyObject *pTmp = NULL;
PyObject *pFile; /* Don't decref, it's borrowed! */
attempt {
int tmp;
tmp = PyArg_ParseTupleAndKeywords(args, kwds, "O|sll", kwlist, &pFile, &mode, &snaplen, &linktype);
if (! tmp) break;
if (PyString_Check(pFile)) {
char *fn;
fn = PyString_AsString(pFile);
if (! fn) break;
if (NULL == mode) {
mode = "rb";
}
pFile = PyFile_FromString(fn, mode);
if (! pFile) break;
self->pFile = pFile;
} else {
self->pFile = pFile;
Py_INCREF(self->pFile);
}
if ((! mode) || ('r' == mode[0])) {
/* Try to read in the header. */
pTmp = PyObject_CallMethod(pFile, "read", "i", sizeof(self->header));
if (0 == mode) {
/* If we're in auto-detect mode... */
if (pTmp) {
/* And it worked, then we become read-only */
self->mode = 'r';
} else {
/* And it didn't work, then we become write-only */
PyErr_Clear();
self->mode = 'w';
}
} else {
self->mode = mode[0];
}
} else {
self->mode = mode[0];
}
if ('r' == self->mode) {
if (! pTmp) break;
{
int tmp;
char *buf;
int len;
tmp = PyString_AsStringAndSize(pTmp, &buf, &len);
if (-1 == tmp) {
break;
}
if (len != sizeof(self->header)) {
PyErr_Format(PyExc_IOError, "Reading header returned wrong number of bytes");
break;
}
memcpy(&(self->header), buf, len);
}
if (0xa1b2c3d4 == self->header.magic) {
self->swap = 0;
} else if (0xd4c3b2a1 == self->header.magic) {
self->swap = 1;
} else {
PyErr_Format(PyExc_IOError, "Not a pcap file");
break;
}
} else if ('w' == self->mode) {
/* Write out header */
memset(&(self->header), 0, sizeof(self->header));
self->header.magic = 0xa1b2c3d4;
self->header.version_major = 2;
self->header.version_minor = 4;
self->header.snaplen = snaplen;
self->header.linktype = linktype;
self->swap = 0;
pTmp = PyObject_CallMethod(pFile, "write", "s#", &(self->header), sizeof(self->header));
if (! pTmp) break;
} else {
PyErr_Format(PyExc_IOError, "mode must be 'r' or 'w'");
break;
}
}
recover {
Py_CLEAR(self->pFile);
Py_CLEAR(pTmp);
return -1;
}
return 0;
}
void
Py_InitializeEx(int install_sigs)
{
PyInterpreterState *interp;
PyThreadState *tstate;
PyObject *bimod, *sysmod;
char *p;
#if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
char *codeset;
char *saved_locale;
PyObject *sys_stream, *sys_isatty;
#endif
extern void _Py_ReadyTypes(void);
if (initialized)
return;
initialized = 1;
if ((p = Py_GETENV("PYTHONDEBUG")) && *p != '\0')
Py_DebugFlag = add_flag(Py_DebugFlag, p);
if ((p = Py_GETENV("PYTHONVERBOSE")) && *p != '\0')
Py_VerboseFlag = add_flag(Py_VerboseFlag, p);
if ((p = Py_GETENV("PYTHONOPTIMIZE")) && *p != '\0')
Py_OptimizeFlag = add_flag(Py_OptimizeFlag, p);
interp = PyInterpreterState_New();
if (interp == NULL)
Py_FatalError("Py_Initialize: can't make first interpreter");
tstate = PyThreadState_New(interp);
if (tstate == NULL)
Py_FatalError("Py_Initialize: can't make first thread");
(void) PyThreadState_Swap(tstate);
#ifdef STACKLESS
if (!_PyStackless_InitTypes()) {
PyErr_Print();
Py_FatalError("Py_Initialize: can't init stackless types");
}
#endif
_Py_ReadyTypes();
if (!_PyFrame_Init())
Py_FatalError("Py_Initialize: can't init frames");
if (!_PyInt_Init())
Py_FatalError("Py_Initialize: can't init ints");
_PyFloat_Init();
interp->modules = PyDict_New();
if (interp->modules == NULL)
Py_FatalError("Py_Initialize: can't make modules dictionary");
interp->modules_reloading = PyDict_New();
if (interp->modules_reloading == NULL)
Py_FatalError("Py_Initialize: can't make modules_reloading dictionary");
#ifdef Py_USING_UNICODE
/* Init Unicode implementation; relies on the codec registry */
_PyUnicode_Init();
#endif
bimod = _PyBuiltin_Init();
if (bimod == NULL)
Py_FatalError("Py_Initialize: can't initialize __builtin__");
interp->builtins = PyModule_GetDict(bimod);
if (interp->builtins == NULL)
Py_FatalError("Py_Initialize: can't initialize builtins dict");
Py_INCREF(interp->builtins);
sysmod = _PySys_Init();
if (sysmod == NULL)
Py_FatalError("Py_Initialize: can't initialize sys");
interp->sysdict = PyModule_GetDict(sysmod);
if (interp->sysdict == NULL)
Py_FatalError("Py_Initialize: can't initialize sys dict");
Py_INCREF(interp->sysdict);
_PyImport_FixupExtension("sys", "sys");
PySys_SetPath(Py_GetPath());
PyDict_SetItemString(interp->sysdict, "modules",
interp->modules);
_PyImport_Init();
/* initialize builtin exceptions */
_PyExc_Init();
_PyImport_FixupExtension("exceptions", "exceptions");
/* phase 2 of builtins */
_PyImport_FixupExtension("__builtin__", "__builtin__");
_PyImportHooks_Init();
if (install_sigs)
initsigs(); /* Signal handling stuff, including initintr() */
#ifdef STACKLESS
_PyStackless_Init();
#endif
initmain(); /* Module __main__ */
if (!Py_NoSiteFlag)
initsite(); /* Module site */
/* auto-thread-state API, if available */
#ifdef WITH_THREAD
_PyGILState_Init(interp, tstate);
#endif /* WITH_THREAD */
warnings_module = PyImport_ImportModule("warnings");
if (!warnings_module)
PyErr_Clear();
#if defined(Py_USING_UNICODE) && defined(HAVE_LANGINFO_H) && defined(CODESET)
/* On Unix, set the file system encoding according to the
user's preference, if the CODESET names a well-known
Python codec, and Py_FileSystemDefaultEncoding isn't
initialized by other means. Also set the encoding of
stdin and stdout if these are terminals. */
saved_locale = strdup(setlocale(LC_CTYPE, NULL));
setlocale(LC_CTYPE, "");
codeset = nl_langinfo(CODESET);
if (codeset && *codeset) {
PyObject *enc = PyCodec_Encoder(codeset);
if (enc) {
codeset = strdup(codeset);
Py_DECREF(enc);
} else {
codeset = NULL;
PyErr_Clear();
}
} else
codeset = NULL;
setlocale(LC_CTYPE, saved_locale);
free(saved_locale);
if (codeset) {
sys_stream = PySys_GetObject("stdin");
sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
if (!sys_isatty)
PyErr_Clear();
if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
PyFile_Check(sys_stream)) {
if (!PyFile_SetEncoding(sys_stream, codeset))
Py_FatalError("Cannot set codeset of stdin");
}
Py_XDECREF(sys_isatty);
sys_stream = PySys_GetObject("stdout");
sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
if (!sys_isatty)
PyErr_Clear();
if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
PyFile_Check(sys_stream)) {
if (!PyFile_SetEncoding(sys_stream, codeset))
Py_FatalError("Cannot set codeset of stdout");
}
Py_XDECREF(sys_isatty);
sys_stream = PySys_GetObject("stderr");
sys_isatty = PyObject_CallMethod(sys_stream, "isatty", "");
if (!sys_isatty)
PyErr_Clear();
if(sys_isatty && PyObject_IsTrue(sys_isatty) &&
PyFile_Check(sys_stream)) {
if (!PyFile_SetEncoding(sys_stream, codeset))
Py_FatalError("Cannot set codeset of stderr");
}
Py_XDECREF(sys_isatty);
if (!Py_FileSystemDefaultEncoding)
Py_FileSystemDefaultEncoding = codeset;
else
free(codeset);
}
#endif
}
static int
modena_model_t_init(modena_model_t *self, PyObject *args, PyObject *kwds)
{
PyObject *pParameters=NULL, *pModel=NULL;
char *modelId=NULL;
static char *kwlist[] = {"model", "modelId", "parameters"};
if
(
!PyArg_ParseTupleAndKeywords
(
args, kwds, "|OsO", kwlist, &pModel, &modelId, &pParameters
)
)
{
return -1;
}
if(!pModel)
{
PyObject *pName = PyString_FromString("modena.SurrogateModel");
if(!pName){ Modena_PyErr_Print(); }
PyObject *pModule = PyImport_Import(pName);
Py_DECREF(pName);
if(!pModule){ Modena_PyErr_Print(); }
PyObject *pDict = PyModule_GetDict(pModule); // Borrowed ref
if(!pDict){ Modena_PyErr_Print(); }
pName = PyString_FromString("SurrogateModel");
if(!pName){ Modena_PyErr_Print(); }
PyObject *sModel = PyObject_GetItem(pDict, pName);
Py_DECREF(pName);
if(!sModel){ Modena_PyErr_Print(); }
self->pModel = PyObject_CallMethod(sModel, "load", "(z)", modelId);
Py_DECREF(sModel);
if(!self->pModel){ Modena_PyErr_Print(); }
modena_model_get_minMax(self);
Py_DECREF(pModule);
}
else
{
Py_INCREF(pModel);
self->pModel = pModel;
// Set everything to zero
self->inputs_minMax_size = 0;
self->inputs_min = NULL;
self->inputs_max = NULL;
}
//PyObject_Print(self->pModel, stdout, 0);
//printf("\n");
PyObject *pOutputs = PyObject_GetAttrString(self->pModel, "outputs");
if(!pOutputs){ Modena_PyErr_Print(); }
self->outputs_size = PyDict_Size(pOutputs);
Py_DECREF(pOutputs);
PyObject *pMaxArgPos = PyObject_CallMethod
(
self->pModel, "inputs_max_argPos", NULL
);
if(!pMaxArgPos){ Modena_PyErr_Print(); }
self->inputs_size = 1 + PyInt_AsSsize_t(pMaxArgPos);
Py_DECREF(pMaxArgPos);
self->inherited_inputs_size = 0;
// Avoiding double indirection in modena_model_call
// Use modena_function_new to construct, then copy function pointer
self->mf = modena_function_new(self);
self->function = self->mf->function;
self->argPos_used = malloc
(
(self->inputs_size + self->inherited_inputs_size)*sizeof(bool)
);
modena_model_read_substituteModels(self);
if(!pParameters)
{
pParameters = PyObject_GetAttrString(self->pModel, "parameters");
if(!pParameters){ Modena_PyErr_Print(); }
}
else
{
Py_INCREF(pParameters);
}
PyObject *pSeq = PySequence_Fast(pParameters, "expected a sequence");
self->parameters_size = PySequence_Size(pParameters);
self->parameters = malloc(self->parameters_size*sizeof(double));
size_t i;
for(i = 0; i < self->parameters_size; i++)
{
self->parameters[i] = PyFloat_AsDouble(PyList_GET_ITEM(pSeq, i));
}
Py_DECREF(pSeq);
Py_DECREF(pParameters);
if(PyErr_Occurred()){ Modena_PyErr_Print(); }
return 0;
}
extern "C" PyObject* generate_mipmap(PyObject*, PyObject* args)
{
// Convert some of this Python nonsense to good old C
PyObject* blTexImage = nullptr; // unchecked... better be right
PyObject* pymm = nullptr;
if (PyArg_ParseTuple(args, "OO", &blTexImage, &pymm) && blTexImage && pymm) {
// Since we can't link with PyHSPlasma easily, let's do some roundabout type-checking
korlib::pyref classindex = PyObject_CallMethod(pymm, "ClassIndex", "");
static short mipmap_classindex = plFactory::ClassIndex("plMipmap");
if (PyLong_AsLong(classindex) != mipmap_classindex) {
PyErr_SetString(PyExc_TypeError, "generate_mipmap expects a Blender ImageTexture and a plMipmap");
return nullptr;
}
} else {
PyErr_SetString(PyExc_TypeError, "generate_mipmap expects a Blender ImageTexture and a plMipmap");
return nullptr;
}
// Grab the important stuff
plMipmap* mipmap = ((pyMipmap*)pymm)->fThis;
korlib::pyref blImage = korlib::getattr<PyObject*>(blTexImage, "image");
bool makeMipMap = korlib::getattr<bool>(blTexImage, "use_mipmap");
bool useAlpha = korlib::getattr<bool>(blTexImage, "use_alpha");
bool calcAlpha = korlib::getattr<bool>(blTexImage, "use_calculate_alpha");
// Okay, so, here are the assumptions.
// We assume that the Korman Python code as already created the mipmap's key and named it appropriately
// So, if we're mipmapping nb01StoneSquareCobble.tga -> nb01StoneSquareCobble.dds as the key name
// What we now need to do:
// 1) Make sure this is a POT texture (if not, call scale on the Blender Image)
// 2) Check calcAlpha and all that rubbish--det DXT1/DXT5/uncompressed
// 3) "Create" the plMipmap--this allocates internal buffers and such
// 4) Loop through the levels, going down through the POTs and fill in the pixel data
// The reason we do this in C instead of python is because it's a lot of iterating over a lot of
// floating point data (we have to convert to RGB8888, joy). Should be faster here!
print("Exporting '%s'...", mipmap->getKey()->getName().cstr());
// Step 1: Resize to POT (if needed) -- don't rely on GLU for this because it may not suppport
// NPOT if we're being run on some kind of dinosaur...
imagesize_t dimensions = get_image_size(blImage);
size_t width = pow(2., korlib::log2(static_cast<double>(std::get<0>(dimensions))));
size_t height = pow(2., korlib::log2(static_cast<double>(std::get<1>(dimensions))));
if (std::get<0>(dimensions) != width || std::get<1>(dimensions) != height) {
print("\tImage is not a POT (%dx%d)... resizing to %dx%d", std::get<0>(dimensions),
std::get<1>(dimensions), width, height);
resize_image(blImage, width, height);
}
// Steps 2+3: Translate flags and pass to plMipmap::Create
// TODO: PNG compression for lossless images
uint8_t numLevels = (makeMipMap) ? 0 : 1; // 0 means "you figure it out"
uint8_t compType = (makeMipMap) ? plBitmap::kDirectXCompression : plBitmap::kUncompressed;
bool alphaChannel = useAlpha || calcAlpha;
mipmap->Create(width, height, numLevels, compType, plBitmap::kRGB8888, alphaChannel ? plBitmap::kDXT5 : plBitmap::kDXT1);
// Step 3.9: Load the image into OpenGL
gl_loadimage guard(blImage);
if (!guard.success()) {
PyErr_SetString(PyExc_RuntimeError, "failed to load image into OpenGL");
return nullptr;
}
// Step 4: Now it's a matter of looping through all the levels and exporting the image
for (size_t i = 0; i < mipmap->getNumLevels(); ++i) {
stuff_mip_level(mipmap, i, blImage, calcAlpha);
}
Py_RETURN_NONE;
}
static PyObject* image_new( PyObject* self, PyObject* args )
{
ImageObject* imageobj = NULL;
PyObject* pilobj = NULL;
PyObject* modestrobj = NULL;
PyObject* sizeobj = NULL;
PyObject* datastrobj = NULL;
unsigned char* data;
char* modestr;
int i;
int pixelsize;
static PyObject* PILmodule = NULL;
PyObject* oldpilobj;
PyObject* nameobj;
if ( !PyArg_ParseTuple( args, "O:new_image", &pilobj ) )
return NULL;
Py_INCREF( pilobj );
if ( PyString_Check( pilobj ) )
{
// object is a string; assume it's a filename and attempt to create the PIL object ourselves;
#if 0
printf( "fine, creating the PIL object myself\n" );
#endif
if ( PILmodule == NULL )
{
PyObject* name = PyString_FromString( "Image" );
PILmodule = PyImport_Import( name );
Py_DECREF( name );
if ( PILmodule == NULL )
{
PyErr_SetString( ImageError, "failed to find PIL module" );
goto error;
}
}
nameobj = pilobj;
oldpilobj = pilobj;
pilobj = PyObject_CallMethod( PILmodule, "open", "O", pilobj );
Py_DECREF( oldpilobj );
if ( pilobj == NULL )
goto error;
Py_INCREF( pilobj );
}
else
nameobj = Py_None;
imageobj = PyObject_New( ImageObject, &ImageType );
Py_INCREF( nameobj );
imageobj->filename = nameobj;
modestrobj = PyObject_GetAttrString( pilobj, "mode" );
modestr = PyString_AsString( modestrobj );
if ( strcmp( modestr, "RGBA" ) == 0 )
{
pixelsize = 4;
}
else if ( strcmp( modestr, "RGB" ) == 0 )
{
pixelsize = 3;
}
else
{
#if 0
printf( "attempting conversion to RGB\n" );
#endif
// need to convert image to RGB
oldpilobj = pilobj;
pilobj = PyObject_CallMethod( pilobj, "convert", "s", "RGB" );
Py_DECREF( oldpilobj );
if ( pilobj == NULL )
goto error;
Py_INCREF( pilobj );
pixelsize = 3;
}
sizeobj = PyObject_GetAttrString( pilobj, "size" );
if ( !PyTuple_Check( sizeobj ) || PyTuple_Size( sizeobj ) != 2 )
{
PyErr_SetString( ImageError, "size attribute is wrong wrong wrong" );
Py_DECREF( sizeobj );
Py_DECREF( pilobj );
return NULL;
}
imageobj->w = PyInt_AsLong( PyTuple_GetItem( sizeobj, 0 ) );
imageobj->h = PyInt_AsLong( PyTuple_GetItem( sizeobj, 1 ) );
if ( imageobj->w < 1 || imageobj->h < 1 )
{
PyErr_Format( ImageError, "PIL says image size is %d x %d; that can't be right",
imageobj->w, imageobj->h );
goto error;
}
#if 0
printf( "image is %d x %d\n", imageobj->w, imageobj->h );
#endif
imageobj->tw = 1;
while( imageobj->tw < imageobj->w )
{
imageobj->tw <<= 1;
if ( imageobj->tw <= 0 )
{
PyErr_SetString( ImageError, "image is too wide" );
goto error;
}
}
imageobj->th = 1;
while( imageobj->th < imageobj->h )
{
imageobj->th <<= 1;
if ( imageobj->th <= 0 )
{
PyErr_SetString( ImageError, "image is too tall" );
goto error;
}
}
#if 0
printf( "texture must be %d x %d\n", imageobj->tw, imageobj->th );
#endif
datastrobj = PyObject_CallMethod( pilobj, "tostring", NULL );
if ( datastrobj == NULL )
goto error;
PyString_AsStringAndSize( datastrobj, (char**)&data, &i );
if ( i != imageobj->w * imageobj->h * pixelsize )
{
PyErr_Format( ImageError, "got %d bytes of image data; expected %d", i,
imageobj->w * imageobj->h * pixelsize );
goto error;
}
imageobj->data = malloc( imageobj->tw * imageobj->th * pixelsize );
for ( i = 0; i < imageobj->h; ++i )
memcpy( imageobj->data + i * (pixelsize * imageobj->tw),
data + i * (pixelsize * imageobj->w),
pixelsize*imageobj->w );
if ( imageobj->w < imageobj->tw )
{
for ( i = 0; i < imageobj->h; ++i )
memcpy( imageobj->data + i * (pixelsize * imageobj->tw) + pixelsize * imageobj->w,
imageobj->data + i * (pixelsize * imageobj->tw) + pixelsize * (imageobj->w-1),
pixelsize );
}
if ( imageobj->h < imageobj->th )
{
memcpy( imageobj->data + imageobj->tw * pixelsize * imageobj->h,
imageobj->data + imageobj->tw * pixelsize * (imageobj->h-1),
imageobj->tw * pixelsize );
}
imageobj->has_alpha = (pixelsize == 4);
imageobj->has_texture = 0;
imageobj->tright = ((double)imageobj->w) / imageobj->tw;
imageobj->tbottom = ((double)imageobj->h) / imageobj->th;
Py_DECREF( datastrobj );
Py_DECREF( sizeobj );
Py_DECREF( modestrobj );
Py_DECREF( pilobj );
return (PyObject*)imageobj;
error:
if ( imageobj )
PyObject_Del( imageobj );
Py_XDECREF( modestrobj );
Py_XDECREF( sizeobj );
Py_XDECREF( datastrobj );
Py_XDECREF( pilobj );
return NULL;
}
static PyObject *
subprocess_fork_exec(PyObject* self, PyObject *args)
{
PyObject *gc_module = NULL;
PyObject *executable_list, *py_close_fds, *py_fds_to_keep;
PyObject *env_list, *preexec_fn;
PyObject *process_args, *converted_args = NULL, *fast_args = NULL;
PyObject *preexec_fn_args_tuple = NULL;
int p2cread, p2cwrite, c2pread, c2pwrite, errread, errwrite;
int errpipe_read, errpipe_write, close_fds, restore_signals;
int call_setsid;
PyObject *cwd_obj, *cwd_obj2;
const char *cwd;
pid_t pid;
int need_to_reenable_gc = 0;
char *const *exec_array, *const *argv = NULL, *const *envp = NULL;
Py_ssize_t arg_num, num_fds_to_keep;
if (!PyArg_ParseTuple(
args, "OOOOOOiiiiiiiiiiO:fork_exec",
&process_args, &executable_list, &py_close_fds, &py_fds_to_keep,
&cwd_obj, &env_list,
&p2cread, &p2cwrite, &c2pread, &c2pwrite,
&errread, &errwrite, &errpipe_read, &errpipe_write,
&restore_signals, &call_setsid, &preexec_fn))
return NULL;
close_fds = PyObject_IsTrue(py_close_fds);
if (close_fds && errpipe_write < 3) { /* precondition */
PyErr_SetString(PyExc_ValueError, "errpipe_write must be >= 3");
return NULL;
}
num_fds_to_keep = PySequence_Length(py_fds_to_keep);
if (num_fds_to_keep < 0) {
PyErr_SetString(PyExc_ValueError, "bad fds_to_keep");
return NULL;
}
/* We need to call gc.disable() when we'll be calling preexec_fn */
if (preexec_fn != Py_None) {
PyObject *result;
gc_module = PyImport_ImportModule("gc");
if (gc_module == NULL)
return NULL;
result = PyObject_CallMethod(gc_module, "isenabled", NULL);
if (result == NULL) {
Py_DECREF(gc_module);
return NULL;
}
need_to_reenable_gc = PyObject_IsTrue(result);
Py_DECREF(result);
if (need_to_reenable_gc == -1) {
Py_DECREF(gc_module);
return NULL;
}
result = PyObject_CallMethod(gc_module, "disable", NULL);
if (result == NULL) {
Py_DECREF(gc_module);
return NULL;
}
Py_DECREF(result);
}
exec_array = _PySequence_BytesToCharpArray(executable_list);
if (!exec_array)
return NULL;
/* Convert args and env into appropriate arguments for exec() */
/* These conversions are done in the parent process to avoid allocating
or freeing memory in the child process. */
if (process_args != Py_None) {
Py_ssize_t num_args;
/* Equivalent to: */
/* tuple(PyUnicode_FSConverter(arg) for arg in process_args) */
fast_args = PySequence_Fast(process_args, "argv must be a tuple");
num_args = PySequence_Fast_GET_SIZE(fast_args);
converted_args = PyTuple_New(num_args);
if (converted_args == NULL)
goto cleanup;
for (arg_num = 0; arg_num < num_args; ++arg_num) {
PyObject *borrowed_arg, *converted_arg;
borrowed_arg = PySequence_Fast_GET_ITEM(fast_args, arg_num);
if (PyUnicode_FSConverter(borrowed_arg, &converted_arg) == 0)
goto cleanup;
PyTuple_SET_ITEM(converted_args, arg_num, converted_arg);
}
argv = _PySequence_BytesToCharpArray(converted_args);
Py_CLEAR(converted_args);
Py_CLEAR(fast_args);
if (!argv)
goto cleanup;
}
if (env_list != Py_None) {
envp = _PySequence_BytesToCharpArray(env_list);
if (!envp)
goto cleanup;
}
if (preexec_fn != Py_None) {
preexec_fn_args_tuple = PyTuple_New(0);
if (!preexec_fn_args_tuple)
goto cleanup;
_PyImport_AcquireLock();
}
if (cwd_obj != Py_None) {
if (PyUnicode_FSConverter(cwd_obj, &cwd_obj2) == 0)
goto cleanup;
cwd = PyBytes_AsString(cwd_obj2);
} else {
cwd = NULL;
cwd_obj2 = NULL;
}
pid = fork();
if (pid == 0) {
/* Child process */
/*
* Code from here to _exit() must only use async-signal-safe functions,
* listed at `man 7 signal` or
* http://www.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_04.html.
*/
if (preexec_fn != Py_None) {
/* We'll be calling back into Python later so we need to do this.
* This call may not be async-signal-safe but neither is calling
* back into Python. The user asked us to use hope as a strategy
* to avoid deadlock... */
PyOS_AfterFork();
}
child_exec(exec_array, argv, envp, cwd,
p2cread, p2cwrite, c2pread, c2pwrite,
errread, errwrite, errpipe_read, errpipe_write,
close_fds, restore_signals, call_setsid,
num_fds_to_keep, py_fds_to_keep,
preexec_fn, preexec_fn_args_tuple);
_exit(255);
return NULL; /* Dead code to avoid a potential compiler warning. */
}
Py_XDECREF(cwd_obj2);
if (pid == -1) {
/* Capture the errno exception before errno can be clobbered. */
PyErr_SetFromErrno(PyExc_OSError);
}
if (preexec_fn != Py_None &&
_PyImport_ReleaseLock() < 0 && !PyErr_Occurred()) {
PyErr_SetString(PyExc_RuntimeError,
"not holding the import lock");
}
/* Parent process */
if (envp)
_Py_FreeCharPArray(envp);
if (argv)
_Py_FreeCharPArray(argv);
_Py_FreeCharPArray(exec_array);
/* Reenable gc in the parent process (or if fork failed). */
if (need_to_reenable_gc && _enable_gc(gc_module)) {
Py_XDECREF(gc_module);
return NULL;
}
Py_XDECREF(preexec_fn_args_tuple);
Py_XDECREF(gc_module);
if (pid == -1)
return NULL; /* fork() failed. Exception set earlier. */
return PyLong_FromPid(pid);
cleanup:
if (envp)
_Py_FreeCharPArray(envp);
if (argv)
_Py_FreeCharPArray(argv);
_Py_FreeCharPArray(exec_array);
Py_XDECREF(converted_args);
Py_XDECREF(fast_args);
Py_XDECREF(preexec_fn_args_tuple);
/* Reenable gc if it was disabled. */
if (need_to_reenable_gc)
_enable_gc(gc_module);
Py_XDECREF(gc_module);
return NULL;
}
void start_watcher(int i, struct uwsgi_socket* uwsgi_sock) {
PyObject_CallMethod(ugevent.watchers[i], "start", "Oli", uwsgi_gevent_main,(long)uwsgi_sock, i);
}
/*@C
PetscPythonInitialize - Initialize Python and import petsc4py.
Input Parameter:
+ pyexe - path to the Python interpreter executable, or NULL.
- pylib - full path to the Python dynamic library, or NULL.
Level: intermediate
.keywords: Python
@*/
PetscErrorCode PetscPythonInitialize(const char pyexe[],const char pylib[])
{
PyObject *module = 0;
PetscErrorCode ierr;
PetscFunctionBegin;
if (PetscBeganPython) PetscFunctionReturn(0);
/* Python executable */
if (pyexe && pyexe[0] != 0) {
ierr = PetscStrncpy(PetscPythonExe,pyexe,sizeof(PetscPythonExe));CHKERRQ(ierr);
} else {
ierr = PetscPythonFindExecutable(PetscPythonExe);CHKERRQ(ierr);
}
/* Python dynamic library */
if (pylib && pylib[0] != 0) {
ierr = PetscStrncpy(PetscPythonLib,pylib,sizeof(PetscPythonLib));CHKERRQ(ierr);
} else {
ierr = PetscPythonFindLibrary(PetscPythonExe,PetscPythonLib);CHKERRQ(ierr);
}
/* dynamically load Python library */
ierr = PetscPythonLoadLibrary(PetscPythonLib);CHKERRQ(ierr);
/* initialize Python */
PetscBeganPython = PETSC_FALSE;
if (!Py_IsInitialized()) {
static PetscBool registered = PETSC_FALSE;
const char *py_version;
PyObject *sys_path;
char path[PETSC_MAX_PATH_LEN] = { 0 };
/* initialize Python */
Py_InitializeEx(0); /* 0: do not install signal handlers */
/* build 'sys.argv' list */
py_version = Py_GetVersion();
if (py_version[0] == '2') {
int argc = 0; char **argv = 0;
ierr = PetscGetArgs(&argc,&argv);CHKERRQ(ierr);
PySys_SetArgv(argc,argv);
}
if (py_version[0] == '3') {
/* XXX 'argv' is type 'wchar_t**' */
PySys_SetArgv(0,NULL);
}
/* add PETSC_LIB_DIR in front of 'sys.path' */
sys_path = PySys_GetObject("path");
if (sys_path) {
ierr = PetscStrreplace(PETSC_COMM_SELF,"${PETSC_LIB_DIR}",path,sizeof(path));CHKERRQ(ierr);
Py_DecRef(PyObject_CallMethod(sys_path,"insert","is",(int)0,(char*)path));
}
/* register finalizer */
if (!registered) {
ierr = PetscRegisterFinalize(PetscPythonFinalize);CHKERRQ(ierr);
registered = PETSC_TRUE;
}
PetscBeganPython = PETSC_TRUE;
}
/* import 'petsc4py.PETSc' module */
module = PyImport_ImportModule("petsc4py.PETSc");
if (module) {
ierr = PetscInfo(0,"Python: successfully imported module 'petsc4py.PETSc'\n");CHKERRQ(ierr);
Py_DecRef(module); module = 0;
} else {
PetscPythonPrintError();
SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Python: could not import module 'petsc4py.PETSc', perhaps your PYTHONPATH does not contain it\n");
}
PetscFunctionReturn(0);
}
PyObject *
Reference_get_object(Reference *self)
{
return PyObject_CallMethod((PyObject *) self, "peel", NULL);
}
void SlowScan::playFile(PyObject* file_path)
{
// Call the function "PrintText" in PythonLand.
pValue = PyObject_CallMethod(pInstance, "playFile", "(O)", file_path);
}
NPY_NO_EXPORT PyArray_Descr*
_descriptor_from_pep3118_format(char *s)
{
char *buf, *p;
int in_name = 0;
int obtained;
PyObject *descr;
PyObject *str;
PyObject *_numpy_internal;
if (s == NULL) {
return PyArray_DescrNewFromType(NPY_BYTE);
}
/* Fast path */
obtained = _descriptor_from_pep3118_format_fast(s, &descr);
if (obtained) {
return (PyArray_Descr*)descr;
}
/* Strip whitespace, except from field names */
buf = malloc(strlen(s) + 1);
if (buf == NULL) {
return NULL;
}
p = buf;
while (*s != '\0') {
if (*s == ':') {
in_name = !in_name;
*p = *s;
p++;
}
else if (in_name || !NumPyOS_ascii_isspace(*s)) {
*p = *s;
p++;
}
s++;
}
*p = '\0';
str = PyUString_FromStringAndSize(buf, strlen(buf));
if (str == NULL) {
free(buf);
return NULL;
}
/* Convert */
_numpy_internal = PyImport_ImportModule("numpy.core._internal");
if (_numpy_internal == NULL) {
Py_DECREF(str);
free(buf);
return NULL;
}
descr = PyObject_CallMethod(
_numpy_internal, "_dtype_from_pep3118", "O", str);
Py_DECREF(str);
Py_DECREF(_numpy_internal);
if (descr == NULL) {
PyErr_Format(PyExc_ValueError,
"'%s' is not a valid PEP 3118 buffer format string", buf);
free(buf);
return NULL;
}
if (!PyArray_DescrCheck(descr)) {
PyErr_Format(PyExc_RuntimeError,
"internal error: numpy.core._internal._dtype_from_pep3118 "
"did not return a valid dtype, got %s", buf);
Py_DECREF(descr);
free(buf);
return NULL;
}
free(buf);
return (PyArray_Descr*)descr;
}
static PyObject *_YIELD_FROM( struct Nuitka_GeneratorObject *generator, PyObject *value )
{
// This is the value, propagated back and forth the sub-generator and the
// yield from consumer.
PyObject *send_value = Py_None;
while( 1 )
{
// Send iteration value to the sub-generator, which may be a CPython
// generator object, something with an iterator next, or a send method,
// where the later is only required if values other than "None" need to
// be passed in.
PyObject *retval;
// Exception, was thrown into us, need to send that to sub-generator.
if ( generator->m_exception_type )
{
// The yielding generator is being closed, but we also are tasked to
// immediately close the currently running sub-generator.
if ( EXCEPTION_MATCH_BOOL_SINGLE( generator->m_exception_type, PyExc_GeneratorExit ) )
{
PyObject *close_method = PyObject_GetAttr( value, const_str_plain_close );
if ( close_method )
{
PyObject *close_value = PyObject_Call( close_method, const_tuple_empty, NULL );
Py_DECREF( close_method );
if (unlikely( close_value == NULL ))
{
return NULL;
}
Py_DECREF( close_value );
}
else
{
PyObject *error = GET_ERROR_OCCURRED();
if ( error != NULL && !EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_AttributeError ) )
{
PyErr_WriteUnraisable( (PyObject *)value );
}
}
RAISE_GENERATOR_EXCEPTION( generator );
return NULL;
}
PyObject *throw_method = PyObject_GetAttr( value, const_str_plain_throw );
if ( throw_method )
{
retval = PyObject_CallFunctionObjArgs( throw_method, generator->m_exception_type, generator->m_exception_value, generator->m_exception_tb, NULL );
Py_DECREF( throw_method );
if (unlikely( send_value == NULL ))
{
if ( EXCEPTION_MATCH_BOOL_SINGLE( GET_ERROR_OCCURRED(), PyExc_StopIteration ) )
{
return ERROR_GET_STOP_ITERATION_VALUE();
}
return NULL;
}
generator->m_exception_type = NULL;
generator->m_exception_value = NULL;
generator->m_exception_tb = NULL;
}
else if ( EXCEPTION_MATCH_BOOL_SINGLE( GET_ERROR_OCCURRED(), PyExc_AttributeError ) )
{
CLEAR_ERROR_OCCURRED();
RAISE_GENERATOR_EXCEPTION( generator );
return NULL;
}
else
{
assert( ERROR_OCCURRED() );
Py_CLEAR( generator->m_exception_type );
Py_CLEAR( generator->m_exception_value );
Py_CLEAR( generator->m_exception_tb );
return NULL;
}
}
else if ( PyGen_CheckExact( value ) )
{
retval = PyGen_Send( (PyGenObject *)value, Py_None );
}
else if ( send_value == Py_None && Py_TYPE( value )->tp_iternext != NULL )
{
retval = Py_TYPE( value )->tp_iternext( value );
}
else
{
// Bug compatibility here, before 3.3 tuples were unrolled in calls, which is what
// PyObject_CallMethod does.
#if PYTHON_VERSION >= 340
retval = PyObject_CallMethodObjArgs( value, const_str_plain_send, send_value, NULL );
#else
retval = PyObject_CallMethod( value, (char *)"send", (char *)"O", send_value );
#endif
}
// Check the sub-generator result
if ( retval == NULL )
{
PyObject *error = GET_ERROR_OCCURRED();
if ( error == NULL )
{
return INCREASE_REFCOUNT( Py_None ) ;
}
// The sub-generator has given an exception. In case of
// StopIteration, we need to check the value, as it is going to be
// the expression value of this "yield from", and we are done. All
// other errors, we need to raise.
if (likely( EXCEPTION_MATCH_BOOL_SINGLE( error, PyExc_StopIteration ) ))
{
return ERROR_GET_STOP_ITERATION_VALUE();
}
return NULL;
}
else
{
generator->m_yielded = retval;
#if PYTHON_VERSION >= 350
generator->m_yieldfrom = value;
#endif
// Return to the calling context.
swapFiber( &generator->m_yielder_context, &generator->m_caller_context );
#if PYTHON_VERSION >= 350
generator->m_yieldfrom = NULL;
#endif
send_value = generator->m_yielded;
CHECK_OBJECT( send_value );
}
}
}
PyObject *ret = PyObject_CallMethod(watcher, "start", "OO", current, watcher);
if (!ret) {
stop_the_watchers_and_clear
return -1;
}
Py_DECREF(ret);
ret = PyObject_CallMethod(timer, "start", "OO", current, timer);
if (!ret) {
stop_the_watchers_and_clear
return -1;
}
Py_DECREF(ret);
ret = PyObject_CallMethod(ugevent.hub, "switch", NULL);
wsgi_req->switches++;
if (!ret) {
stop_the_watchers_and_clear
return -1;
}
Py_DECREF(ret);
if (ret == timer) {
stop_the_watchers_and_clear
return 0;
}
UWSGI_RELEASE_GIL;
ssize_t rlen = read(wsgi_req->poll.fd, tmp_buf+*tmp_pos, remains);
if (rlen <= 0) {
//-------------------------------------------------------------------------------------
PyObject* Map::__py_get(PyObject* self, PyObject* args)
{
return PyObject_CallMethod(static_cast<Map*>(self)->pyDict_,
const_cast<char*>("get"), const_cast<char*>("O"), args);
}
PyObject *
xid_recover(PyObject *conn)
{
PyObject *rv = NULL;
PyObject *curs = NULL;
PyObject *xids = NULL;
xidObject *xid = NULL;
PyObject *recs = NULL;
PyObject *rec = NULL;
PyObject *item = NULL;
PyObject *tmp;
Py_ssize_t len, i;
/* curs = conn.cursor()
* (sort of. Use the real cursor in case the connection returns
* somenthing non-dbapi -- see ticket #114) */
if (!(curs = PyObject_CallFunctionObjArgs(
(PyObject *)&cursorType, conn, NULL))) { goto exit; }
/* curs.execute(...) */
if (!(tmp = PyObject_CallMethod(curs, "execute", "s",
"SELECT gid, prepared, owner, database FROM pg_prepared_xacts")))
{
goto exit;
}
Py_DECREF(tmp);
/* recs = curs.fetchall() */
if (!(recs = PyObject_CallMethod(curs, "fetchall", NULL))) { goto exit; }
/* curs.close() */
if (!(tmp = PyObject_CallMethod(curs, "close", NULL))) { goto exit; }
Py_DECREF(tmp);
/* Build the list with return values. */
if (0 > (len = PySequence_Size(recs))) { goto exit; }
if (!(xids = PyList_New(len))) { goto exit; }
/* populate the xids list */
for (i = 0; i < len; ++i) {
if (!(rec = PySequence_GetItem(recs, i))) { goto exit; }
/* Get the xid with the XA triple set */
if (!(item = PySequence_GetItem(rec, 0))) { goto exit; }
if (!(xid = xid_from_string(item))) { goto exit; }
Py_CLEAR(item);
/* set xid.prepared */
Py_CLEAR(xid->prepared);
if (!(xid->prepared = PySequence_GetItem(rec, 1))) { goto exit; }
/* set xid.owner */
Py_CLEAR(xid->owner);
if (!(xid->owner = PySequence_GetItem(rec, 2))) { goto exit; }
/* set xid.database */
Py_CLEAR(xid->database);
if (!(xid->database = PySequence_GetItem(rec, 3))) { goto exit; }
/* xid finished: add it to the returned list */
PyList_SET_ITEM(xids, i, (PyObject *)xid);
xid = NULL; /* ref stolen */
Py_CLEAR(rec);
}
/* set the return value. */
rv = xids;
xids = NULL;
exit:
Py_XDECREF(xids);
Py_XDECREF(xid);
Py_XDECREF(curs);
Py_XDECREF(recs);
Py_XDECREF(rec);
Py_XDECREF(item);
return rv;
}
/*
*
* Tests for and converts a Python datetime.datetime or datetime.date
* object into a NumPy pandas_datetimestruct. Uses tzinfo (if present)
* to convert to UTC time.
*
* While the C API has PyDate_* and PyDateTime_* functions, the following
* implementation just asks for attributes, and thus supports
* datetime duck typing. The tzinfo time zone conversion would require
* this style of access anyway.
*
* Returns -1 on error, 0 on success, and 1 (with no error set)
* if obj doesn't have the needed date or datetime attributes.
*/
int convert_pydatetime_to_datetimestruct(PyObject *obj,
pandas_datetimestruct *out) {
PyObject *tmp;
int isleap;
/* Initialize the output to all zeros */
memset(out, 0, sizeof(pandas_datetimestruct));
out->month = 1;
out->day = 1;
/* Need at least year/month/day attributes */
if (!PyObject_HasAttrString(obj, "year") ||
!PyObject_HasAttrString(obj, "month") ||
!PyObject_HasAttrString(obj, "day")) {
return 1;
}
/* Get the year */
tmp = PyObject_GetAttrString(obj, "year");
if (tmp == NULL) {
return -1;
}
out->year = PyInt_AsLong(tmp);
if (out->year == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Get the month */
tmp = PyObject_GetAttrString(obj, "month");
if (tmp == NULL) {
return -1;
}
out->month = PyInt_AsLong(tmp);
if (out->month == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Get the day */
tmp = PyObject_GetAttrString(obj, "day");
if (tmp == NULL) {
return -1;
}
out->day = PyInt_AsLong(tmp);
if (out->day == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Validate that the month and day are valid for the year */
if (out->month < 1 || out->month > 12) {
goto invalid_date;
}
isleap = is_leapyear(out->year);
if (out->day < 1 ||
out->day > days_per_month_table[isleap][out->month - 1]) {
goto invalid_date;
}
/* Check for time attributes (if not there, return success as a date) */
if (!PyObject_HasAttrString(obj, "hour") ||
!PyObject_HasAttrString(obj, "minute") ||
!PyObject_HasAttrString(obj, "second") ||
!PyObject_HasAttrString(obj, "microsecond")) {
return 0;
}
/* Get the hour */
tmp = PyObject_GetAttrString(obj, "hour");
if (tmp == NULL) {
return -1;
}
out->hour = PyInt_AsLong(tmp);
if (out->hour == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Get the minute */
tmp = PyObject_GetAttrString(obj, "minute");
if (tmp == NULL) {
return -1;
}
out->min = PyInt_AsLong(tmp);
if (out->min == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Get the second */
tmp = PyObject_GetAttrString(obj, "second");
if (tmp == NULL) {
return -1;
}
out->sec = PyInt_AsLong(tmp);
if (out->sec == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Get the microsecond */
tmp = PyObject_GetAttrString(obj, "microsecond");
if (tmp == NULL) {
return -1;
}
out->us = PyInt_AsLong(tmp);
if (out->us == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
if (out->hour < 0 || out->hour >= 24 || out->min < 0 || out->min >= 60 ||
out->sec < 0 || out->sec >= 60 || out->us < 0 || out->us >= 1000000) {
goto invalid_time;
}
/* Apply the time zone offset if it exists */
if (PyObject_HasAttrString(obj, "tzinfo")) {
tmp = PyObject_GetAttrString(obj, "tzinfo");
if (tmp == NULL) {
return -1;
}
if (tmp == Py_None) {
Py_DECREF(tmp);
} else {
PyObject *offset;
int seconds_offset, minutes_offset;
/* The utcoffset function should return a timedelta */
offset = PyObject_CallMethod(tmp, "utcoffset", "O", obj);
if (offset == NULL) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/*
* The timedelta should have a function "total_seconds"
* which contains the value we want.
*/
tmp = PyObject_CallMethod(offset, "total_seconds", "");
if (tmp == NULL) {
return -1;
}
seconds_offset = PyInt_AsLong(tmp);
if (seconds_offset == -1 && PyErr_Occurred()) {
Py_DECREF(tmp);
return -1;
}
Py_DECREF(tmp);
/* Convert to a minutes offset and apply it */
minutes_offset = seconds_offset / 60;
add_minutes_to_datetimestruct(out, -minutes_offset);
}
}
return 0;
invalid_date:
PyErr_Format(PyExc_ValueError,
"Invalid date (%d,%d,%d) when converting to NumPy datetime",
(int)out->year, (int)out->month, (int)out->day);
return -1;
invalid_time:
PyErr_Format(PyExc_ValueError,
"Invalid time (%d,%d,%d,%d) when converting "
"to NumPy datetime",
(int)out->hour, (int)out->min, (int)out->sec, (int)out->us);
return -1;
}
int main(void)
{
Py_Initialize();
if(!Py_IsInitialized())
return -1;
PyRun_SimpleString("import sys");
//where you put your py file
PyRun_SimpleString("sys.path.append('../')");
//Import
PyObject* pModule = PyImport_ImportModule("pc");//no *.py
if(!pModule)
{
printf("can't open python file!\n");
return -1;
}
//Dict module
PyObject* pDict = PyModule_GetDict(pModule);
if(!pDict)
{
printf("can't find dictionary.\n");
return -1;
}
printDict(pDict);
PyObject *pFunHi = PyDict_GetItemString(pDict, "sayHi");
PyObject_CallFunction(pFunHi, "s", "yourname");// @para1: obj, @para2: name
//release
Py_DECREF(pFunHi);
//Contruct a obj , call it's function
//Second Class
PyObject *pClassSecond = PyDict_GetItemString(pDict , "Second");
if(!pClassSecond)
{
printf("can't find second class.\n");
return -1;
}
//Person Class
PyObject *pClassPerson = PyDict_GetItemString(pDict, "Person");
if(!pClassPerson)
{
printf("can't find Person class.\n");
return -1;
}
//Construct Second Instance
PyObject* pInstanceSecond = PyInstance_New(pClassSecond, NULL, NULL);
if(!pInstanceSecond)
{
printf("can't create second instance.\n");
return -1;
}
//Construct Person Instance
PyObject *pInstancePerson = PyInstance_New(pClassPerson, NULL, NULL);
if(!pInstancePerson)
{
printf("can't create Person instance.\n");
return -1;
}
//pass Person Instance to Second Instance
PyObject_CallMethod(pInstanceSecond, "invoke", "O", pInstancePerson);
PyObject_CallMethod(pInstanceSecond, "method2", "O", pInstancePerson);
//call execute a py file
PyRun_SimpleString("exec(compile(open('./1.py').read(),'1.py', 'exec'),locals(), globals())");
//release
Py_DECREF(pInstanceSecond);
Py_DECREF(pInstancePerson);
Py_DECREF(pClassSecond);
Py_DECREF(pClassPerson);
Py_DECREF(pModule);
Py_Finalize();
return 0;
}
NPY_NO_EXPORT int
PyArray_DTypeFromObjectHelper(PyObject *obj, int maxdims,
PyArray_Descr **out_dtype, int string_type)
{
int i, size;
PyArray_Descr *dtype = NULL;
PyObject *ip;
Py_buffer buffer_view;
/* Check if it's an ndarray */
if (PyArray_Check(obj)) {
dtype = PyArray_DESCR((PyArrayObject *)obj);
Py_INCREF(dtype);
goto promote_types;
}
/* See if it's a python None */
if (obj == Py_None) {
dtype = PyArray_DescrFromType(NPY_OBJECT);
if (dtype == NULL) {
goto fail;
}
Py_INCREF(dtype);
goto promote_types;
}
/* Check if it's a NumPy scalar */
else if (PyArray_IsScalar(obj, Generic)) {
if (!string_type) {
dtype = PyArray_DescrFromScalar(obj);
if (dtype == NULL) {
goto fail;
}
}
else {
int itemsize;
PyObject *temp;
if (string_type == NPY_STRING) {
if ((temp = PyObject_Str(obj)) == NULL) {
return -1;
}
#if defined(NPY_PY3K)
#if PY_VERSION_HEX >= 0x03030000
itemsize = PyUnicode_GetLength(temp);
#else
itemsize = PyUnicode_GET_SIZE(temp);
#endif
#else
itemsize = PyString_GET_SIZE(temp);
#endif
}
else if (string_type == NPY_UNICODE) {
#if defined(NPY_PY3K)
if ((temp = PyObject_Str(obj)) == NULL) {
#else
if ((temp = PyObject_Unicode(obj)) == NULL) {
#endif
return -1;
}
itemsize = PyUnicode_GET_DATA_SIZE(temp);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
}
else {
goto fail;
}
Py_DECREF(temp);
if (*out_dtype != NULL &&
(*out_dtype)->type_num == string_type &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(string_type);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
}
goto promote_types;
}
/* Check if it's a Python scalar */
dtype = _array_find_python_scalar_type(obj);
if (dtype != NULL) {
if (string_type) {
int itemsize;
PyObject *temp;
if (string_type == NPY_STRING) {
if ((temp = PyObject_Str(obj)) == NULL) {
return -1;
}
#if defined(NPY_PY3K)
#if PY_VERSION_HEX >= 0x03030000
itemsize = PyUnicode_GetLength(temp);
#else
itemsize = PyUnicode_GET_SIZE(temp);
#endif
#else
itemsize = PyString_GET_SIZE(temp);
#endif
}
else if (string_type == NPY_UNICODE) {
#if defined(NPY_PY3K)
if ((temp = PyObject_Str(obj)) == NULL) {
#else
if ((temp = PyObject_Unicode(obj)) == NULL) {
#endif
return -1;
}
itemsize = PyUnicode_GET_DATA_SIZE(temp);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
}
else {
goto fail;
}
Py_DECREF(temp);
if (*out_dtype != NULL &&
(*out_dtype)->type_num == string_type &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(string_type);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
}
goto promote_types;
}
/* Check if it's an ASCII string */
if (PyBytes_Check(obj)) {
int itemsize = PyString_GET_SIZE(obj);
/* If it's already a big enough string, don't bother type promoting */
if (*out_dtype != NULL &&
(*out_dtype)->type_num == NPY_STRING &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(NPY_STRING);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
goto promote_types;
}
/* Check if it's a Unicode string */
if (PyUnicode_Check(obj)) {
int itemsize = PyUnicode_GET_DATA_SIZE(obj);
#ifndef Py_UNICODE_WIDE
itemsize <<= 1;
#endif
/*
* If it's already a big enough unicode object,
* don't bother type promoting
*/
if (*out_dtype != NULL &&
(*out_dtype)->type_num == NPY_UNICODE &&
(*out_dtype)->elsize >= itemsize) {
return 0;
}
dtype = PyArray_DescrNewFromType(NPY_UNICODE);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = itemsize;
goto promote_types;
}
/* PEP 3118 buffer interface */
if (PyObject_CheckBuffer(obj) == 1) {
memset(&buffer_view, 0, sizeof(Py_buffer));
if (PyObject_GetBuffer(obj, &buffer_view,
PyBUF_FORMAT|PyBUF_STRIDES) == 0 ||
PyObject_GetBuffer(obj, &buffer_view, PyBUF_FORMAT) == 0) {
PyErr_Clear();
dtype = _descriptor_from_pep3118_format(buffer_view.format);
PyBuffer_Release(&buffer_view);
if (dtype) {
goto promote_types;
}
}
else if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_STRIDES) == 0 ||
PyObject_GetBuffer(obj, &buffer_view, PyBUF_SIMPLE) == 0) {
PyErr_Clear();
dtype = PyArray_DescrNewFromType(NPY_VOID);
dtype->elsize = buffer_view.itemsize;
PyBuffer_Release(&buffer_view);
goto promote_types;
}
else {
PyErr_Clear();
}
}
/* The array interface */
ip = PyArray_GetAttrString_SuppressException(obj, "__array_interface__");
if (ip != NULL) {
if (PyDict_Check(ip)) {
PyObject *typestr;
#if defined(NPY_PY3K)
PyObject *tmp = NULL;
#endif
typestr = PyDict_GetItemString(ip, "typestr");
#if defined(NPY_PY3K)
/* Allow unicode type strings */
if (PyUnicode_Check(typestr)) {
tmp = PyUnicode_AsASCIIString(typestr);
typestr = tmp;
}
#endif
if (typestr && PyBytes_Check(typestr)) {
dtype =_array_typedescr_fromstr(PyBytes_AS_STRING(typestr));
#if defined(NPY_PY3K)
if (tmp == typestr) {
Py_DECREF(tmp);
}
#endif
Py_DECREF(ip);
if (dtype == NULL) {
goto fail;
}
goto promote_types;
}
}
Py_DECREF(ip);
}
/* The array struct interface */
ip = PyArray_GetAttrString_SuppressException(obj, "__array_struct__");
if (ip != NULL) {
PyArrayInterface *inter;
char buf[40];
if (NpyCapsule_Check(ip)) {
inter = (PyArrayInterface *)NpyCapsule_AsVoidPtr(ip);
if (inter->two == 2) {
PyOS_snprintf(buf, sizeof(buf),
"|%c%d", inter->typekind, inter->itemsize);
dtype = _array_typedescr_fromstr(buf);
Py_DECREF(ip);
if (dtype == NULL) {
goto fail;
}
goto promote_types;
}
}
Py_DECREF(ip);
}
/* The old buffer interface */
#if !defined(NPY_PY3K)
if (PyBuffer_Check(obj)) {
dtype = PyArray_DescrNewFromType(NPY_VOID);
if (dtype == NULL) {
goto fail;
}
dtype->elsize = Py_TYPE(obj)->tp_as_sequence->sq_length(obj);
PyErr_Clear();
goto promote_types;
}
#endif
/* The __array__ attribute */
ip = PyArray_GetAttrString_SuppressException(obj, "__array__");
if (ip != NULL) {
Py_DECREF(ip);
ip = PyObject_CallMethod(obj, "__array__", NULL);
if(ip && PyArray_Check(ip)) {
dtype = PyArray_DESCR((PyArrayObject *)ip);
Py_INCREF(dtype);
Py_DECREF(ip);
goto promote_types;
}
Py_XDECREF(ip);
if (PyErr_Occurred()) {
goto fail;
}
}
/* Not exactly sure what this is about... */
#if !defined(NPY_PY3K)
if (PyInstance_Check(obj)) {
dtype = _use_default_type(obj);
if (dtype == NULL) {
goto fail;
}
else {
goto promote_types;
}
}
#endif
/*
* If we reached the maximum recursion depth without hitting one
* of the above cases, the output dtype should be OBJECT
*/
if (maxdims == 0 || !PySequence_Check(obj)) {
if (*out_dtype == NULL || (*out_dtype)->type_num != NPY_OBJECT) {
Py_XDECREF(*out_dtype);
*out_dtype = PyArray_DescrFromType(NPY_OBJECT);
if (*out_dtype == NULL) {
return -1;
}
}
return 0;
}
/* Recursive case */
size = PySequence_Size(obj);
if (size < 0) {
goto fail;
}
/* Recursive call for each sequence item */
for (i = 0; i < size; ++i) {
int res;
ip = PySequence_GetItem(obj, i);
if (ip == NULL) {
goto fail;
}
res = PyArray_DTypeFromObjectHelper(ip, maxdims - 1,
out_dtype, string_type);
if (res < 0) {
Py_DECREF(ip);
goto fail;
}
else if (res > 0) {
Py_DECREF(ip);
return res;
}
Py_DECREF(ip);
}
return 0;
promote_types:
/* Set 'out_dtype' if it's NULL */
if (*out_dtype == NULL) {
if (!string_type && dtype->type_num == NPY_STRING) {
Py_DECREF(dtype);
return RETRY_WITH_STRING;
}
if (!string_type && dtype->type_num == NPY_UNICODE) {
Py_DECREF(dtype);
return RETRY_WITH_UNICODE;
}
*out_dtype = dtype;
return 0;
}
/* Do type promotion with 'out_dtype' */
else {
PyArray_Descr *res_dtype = PyArray_PromoteTypes(dtype, *out_dtype);
Py_DECREF(dtype);
if (res_dtype == NULL) {
return -1;
}
if (!string_type &&
res_dtype->type_num == NPY_UNICODE &&
(*out_dtype)->type_num != NPY_UNICODE) {
Py_DECREF(res_dtype);
return RETRY_WITH_UNICODE;
}
if (!string_type &&
res_dtype->type_num == NPY_STRING &&
(*out_dtype)->type_num != NPY_STRING) {
Py_DECREF(res_dtype);
return RETRY_WITH_STRING;
}
Py_DECREF(*out_dtype);
*out_dtype = res_dtype;
return 0;
}
fail:
Py_XDECREF(*out_dtype);
*out_dtype = NULL;
return -1;
}
#undef RETRY_WITH_STRING
#undef RETRY_WITH_UNICODE
/* new reference */
NPY_NO_EXPORT PyArray_Descr *
_array_typedescr_fromstr(char *c_str)
{
PyArray_Descr *descr = NULL;
PyObject *stringobj = PyString_FromString(c_str);
if (stringobj == NULL) {
return NULL;
}
if (PyArray_DescrConverter(stringobj, &descr) != NPY_SUCCEED) {
Py_DECREF(stringobj);
return NULL;
}
Py_DECREF(stringobj);
return descr;
}
NPY_NO_EXPORT char *
index2ptr(PyArrayObject *mp, npy_intp i)
{
npy_intp dim0;
if (PyArray_NDIM(mp) == 0) {
PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed");
return NULL;
}
dim0 = PyArray_DIMS(mp)[0];
if (check_and_adjust_index(&i, dim0, 0) < 0)
return NULL;
if (i == 0) {
return PyArray_DATA(mp);
}
return PyArray_BYTES(mp)+i*PyArray_STRIDES(mp)[0];
}
ofxPythonObject ofxPythonObject::method(const string &method_name)
{
return make_object_owned(
PyObject_CallMethod(get()->obj,noconststring(method_name),NULL));
}
static PyObject *
LDAPEntry_rename(LDAPEntry *self, PyObject *args, PyObject *kwds) {
int rc;
char *newparent_str, *newrdn_str, *olddn_str;
PyObject *newdn, *newparent, *newrdn;
PyObject *tmp;
char *kwlist[] = {"newdn", NULL};
/* Client must be set. */
if (self->client == NULL) {
PyErr_SetString(PyExc_AttributeError, "LDAPClient is not set.");
return NULL;
}
/* Client must be connected. */
if (!self->client->connected) {
PyObject *ldaperror = get_error("NotConnected");
PyErr_SetString(ldaperror, "Client has to connect to the server first.");
Py_DECREF(ldaperror);
return NULL;
}
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist, &newdn)) {
PyErr_SetString(PyExc_AttributeError, "Wrong parameter.");
return NULL;
}
/* Save old dn string. */
tmp = PyObject_Str(self->dn);
olddn_str = PyObject2char(tmp);
Py_DECREF(tmp);
if (olddn_str == NULL) return NULL;
/* Validate and set new LDAP DN. */
if (LDAPEntry_setDN(self, newdn, NULL) != 0) return NULL;
/* Get rdn and parent strings. */
newrdn = PyObject_CallMethod(self->dn, "get_rdn", "(i)", 0);
newparent = PyObject_CallMethod(self->dn, "get_ancestors", NULL);
if (newrdn == NULL || newparent == NULL) return NULL;
newrdn_str = PyObject2char(newrdn);
newparent_str = PyObject2char(newparent);
Py_DECREF(newrdn);
Py_DECREF(newparent);
rc = ldap_rename_s(self->client->ld, olddn_str, newrdn_str, newparent_str, 1, NULL, NULL);
if (rc != LDAP_SUCCESS) {
//TODO Proper errors
PyObject *ldaperror = get_error("LDAPError");
PyErr_SetString(ldaperror, ldap_err2string(rc));
Py_DECREF(ldaperror);
free(olddn_str);
free(newrdn_str);
free(newparent_str);
return NULL;
}
free(olddn_str);
free(newrdn_str);
free(newparent_str);
return Py_None;
}
// Returns a new string
MCHAR * pythonExceptionTraceback( bool clearException )
{
/*
import traceback
return '\n'.join(traceback.format_exc()).encode('ascii','replace')
*/
MCHAR * ret = 0;
bool success = false;
PyObject * type, * value, * traceback;
/* Save the current exception */
PyErr_Fetch(&type, &value, &traceback);
if( type ) {
PyObject * traceback_module = PyImport_ImportModule("traceback");
if (traceback_module) {
/* Call the traceback module's format_exception function, which returns a list */
PyObject * traceback_list = PyObject_CallMethod(traceback_module, "format_exception", "OOO", type, value ? value : Py_None, traceback ? traceback : Py_None);
if( traceback_list ) {
PyObject * separator = PyString_FromString("");
if( separator ) {
PyObject * retUni = PyUnicode_Join(separator, traceback_list);
if( retUni ) {
#ifdef UNICODE
ret = _tcsdup( PyUnicode_AsUnicode(retUni) );
#else
PyObject * retAscii = PyUnicode_AsEncodedString(retUni, "ascii", "replace");
if( retAscii ) {
Py_ssize_t len = 0;
char * tmp;
if( PyString_AsStringAndSize( retAscii, &tmp, &len ) != -1 ) {
ret = strdup( tmp );//, len );
success = true;
} else {
ret = _tcsdup( _T("Uhoh, failed to get pointer to ascii representation of the exception") );
success = false;
}
Py_DECREF( retAscii );
} else {
ret = _tcsdup( _T("Uhoh, encoding exception to ascii failed") );
success = false;
}
#endif
Py_DECREF(retUni);
} else
ret = _tcsdup(_T("PyUnicode_Join failed"));
Py_DECREF(separator);
} else
ret = _tcsdup(_T("PyUnicode_FromString failed"));
Py_DECREF(traceback_list);
} else
ret = _tcsdup(_T("Failure calling traceback.format_exception"));
Py_DECREF(traceback_module);
} else
ret = _tcsdup(_T("Unable to load the traceback module, can't get exception text"));
} else
ret = _tcsdup(_T("pythonExceptionTraceback called, but no exception set"));
if( clearException ) {
Py_DECREF(type);
Py_XDECREF(value);
Py_XDECREF(traceback);
} else
PyErr_Restore(type,value,traceback);
return ret;
}
/*
modena_model_call returns:
201: requesting exit for new DOE without Restart
200: requesting exit for new DOE with Restart
100: updated model parameters, requesting to continue this run
1: failure
0: okay
If exit is requested, do what's necessary and exit with the same error code!
*/
int modena_model_call
(
modena_model_t *m,
modena_inputs_t *inputs,
modena_outputs_t *outputs
)
{
size_t j;
for(j = 0; j < m->substituteModels_size; j++)
{
modena_substitute_model_call(&m->substituteModels[j], m, inputs);
}
for(j = 0; j < m->inputs_minMax_size; j++)
{
/*
printf
(
"j = %zu %g < %g || %g > %g\n",
j,
inputs->inputs[j],
m->inputs_min[j],
inputs->inputs[j],
m->inputs_max[j]
);
*/
if
(
inputs->inputs[j] < m->inputs_min[j]
|| inputs->inputs[j] > m->inputs_max[j]
)
{
PyObject* pOutside = PyList_New(m->inputs_minMax_size);
for(j = 0; j < m->inputs_minMax_size; j++)
{
PyList_SET_ITEM
(
pOutside, j, PyFloat_FromDouble(inputs->inputs[j])
);
}
PyObject *pRet = PyObject_CallMethod
(
m->pModel, "outOfBounds", "(O)", pOutside
);
Py_DECREF(pOutside);
if(!pRet){ Modena_PyErr_Print(); }
int ret = PyInt_AsLong(pRet);
Py_DECREF(pRet);
return ret;
}
}
m->function
(
m->parameters,
inputs->inherited_inputs,
inputs->inputs,
outputs->outputs
);
return 0;
}
FIATQuadratureAdapter::FIATQuadratureAdapter( PyObject *py_quad_factory ,
int order ) :
QuadratureFamilyBase( order ) , pts_(3) , wts_(3)
{
for (i=0;i<3;i++) {
stack<PyObject *> to_decref;
// call the factory function with shape and order
// to get the FIAT quadrature rule for that shape
PyObject *py_quad_rule =
PyObject_CallFunction( py_quad_factory , "(ii)" , i+1 , order );
TEUCHOS_TEST_FOR_EXCEPTION( !py_quad_rule , std::runtime_error ,
"Unable to construct quadrature rule" );
to_decref.push( py_quad_rule );
PyObject *py_quad_points =
PyObject_CallMethod( py_quad_rule , "get_points" , NULL );
TEUCHOS_TEST_FOR_EXCEPTION( !py_quad_points , std::runtime_error ,
"Unable to extract quadrature points" );
to_decref.push( py_quad_points );
PyObject *py_quad_weights =
PyObject_CallMethod( py_quad_rule , "get_weights" , NULL );
TEUCHOS_TEST_FOR_EXCEPTION( !py_quad_weights , std::runtime_error ,
"Unable to extract quadrature weights" );
int num_points = PyObject_Length( py_quad_points );
TEUCHOS_TEST_FOR_EXCEPTION( (num_points < 1) , std::runtime_error ,
"Not enough points" );
TEUCHOS_TEST_FOR_EXCEPTION( (num_points != PyObject_Length( py_quad_weights ) ) ,
std::runtime_error ,
"Number of points and weights don't match" );
to_decref.push( py_quad_weights );
// get ready to copy data
pts_[i].resize( num_points );
wts_[i].resize( num_points );
for (int j=0;j<num_points;j++) {
pts_[i][j].resize(i+1);
}
// copy data for the points
// lookup functions into list and tuple are borrowed reference
// and hence don't need to be decrefed
for (int j=0;j<num_points;j++) {
// Get a tuple that is the current point
PyObject *py_pt_cur = PyList_GetItem( py_quad_points , j );
for (k=0;k<i+1;k++) {
PyObject *py_pt_cur_k = PyTuple_GetItem( py_pt_cur , k );
pts_[i][j][k] = PyFloat_AsDouble( py_pt_cur_k );
}
}
// copy data for weights
// since they are a Numeric array, I go through the
// object protocol and have to decref.
for (int j=0;j<num_points;j++) {
PyObject *py_j = PyInt_FromLong( (long) j );
PyObject *py_wt_cur = PyObject_GetItem( py_quad_weights , py_j );
wts_[i][j] = PyFloat_AsDouble( py_wt_cur );
to_decref.push( py_j );
to_decref.push( py_wt_cur );
}
while( !to_decref.empty() ) {
PyObject *foo = to_decref.top();
Py_DECREF( foo );
to_decref.pop();
}
}
}
/* This is the main function. Read this to understand how the
* collection process works. */
static Py_ssize_t
collect(int generation)
{
int i;
Py_ssize_t m = 0; /* # objects collected */
Py_ssize_t n = 0; /* # unreachable objects that couldn't be collected */
PyGC_Head *young; /* the generation we are examining */
PyGC_Head *old; /* next older generation */
PyGC_Head unreachable; /* non-problematic unreachable trash */
PyGC_Head finalizers; /* objects with, & reachable from, __del__ */
PyGC_Head *gc;
double t1 = 0.0;
if (delstr == NULL) {
delstr = PyString_InternFromString("__del__");
if (delstr == NULL)
Py_FatalError("gc couldn't allocate \"__del__\"");
}
if (debug & DEBUG_STATS) {
if (tmod != NULL) {
PyObject *f = PyObject_CallMethod(tmod, "time", NULL);
if (f == NULL) {
PyErr_Clear();
}
else {
t1 = PyFloat_AsDouble(f);
Py_DECREF(f);
}
}
PySys_WriteStderr("gc: collecting generation %d...\n",
generation);
PySys_WriteStderr("gc: objects in each generation:");
for (i = 0; i < NUM_GENERATIONS; i++)
PySys_WriteStderr(" %" PY_FORMAT_SIZE_T "d",
gc_list_size(GEN_HEAD(i)));
PySys_WriteStderr("\n");
}
/* update collection and allocation counters */
if (generation+1 < NUM_GENERATIONS)
generations[generation+1].count += 1;
for (i = 0; i <= generation; i++)
generations[i].count = 0;
/* merge younger generations with one we are currently collecting */
for (i = 0; i < generation; i++) {
gc_list_merge(GEN_HEAD(i), GEN_HEAD(generation));
}
/* handy references */
young = GEN_HEAD(generation);
if (generation < NUM_GENERATIONS-1)
old = GEN_HEAD(generation+1);
else
old = young;
/* Using ob_refcnt and gc_refs, calculate which objects in the
* container set are reachable from outside the set (i.e., have a
* refcount greater than 0 when all the references within the
* set are taken into account).
*/
update_refs(young);
subtract_refs(young);
/* Leave everything reachable from outside young in young, and move
* everything else (in young) to unreachable.
* NOTE: This used to move the reachable objects into a reachable
* set instead. But most things usually turn out to be reachable,
* so it's more efficient to move the unreachable things.
*/
gc_list_init(&unreachable);
move_unreachable(young, &unreachable);
/* Move reachable objects to next generation. */
if (young != old)
gc_list_merge(young, old);
/* All objects in unreachable are trash, but objects reachable from
* finalizers can't safely be deleted. Python programmers should take
* care not to create such things. For Python, finalizers means
* instance objects with __del__ methods. Weakrefs with callbacks
* can also call arbitrary Python code but they will be dealt with by
* handle_weakrefs().
*/
gc_list_init(&finalizers);
move_finalizers(&unreachable, &finalizers);
/* finalizers contains the unreachable objects with a finalizer;
* unreachable objects reachable *from* those are also uncollectable,
* and we move those into the finalizers list too.
*/
move_finalizer_reachable(&finalizers);
/* Collect statistics on collectable objects found and print
* debugging information.
*/
for (gc = unreachable.gc.gc_next; gc != &unreachable;
gc = gc->gc.gc_next) {
m++;
if (debug & DEBUG_COLLECTABLE) {
debug_cycle("collectable", FROM_GC(gc));
}
if (tmod != NULL && (debug & DEBUG_STATS)) {
PyObject *f = PyObject_CallMethod(tmod, "time", NULL);
if (f == NULL) {
PyErr_Clear();
}
else {
t1 = PyFloat_AsDouble(f)-t1;
Py_DECREF(f);
PySys_WriteStderr("gc: %.4fs elapsed.\n", t1);
}
}
}
/* Clear weakrefs and invoke callbacks as necessary. */
m += handle_weakrefs(&unreachable, old);
/* Call tp_clear on objects in the unreachable set. This will cause
* the reference cycles to be broken. It may also cause some objects
* in finalizers to be freed.
*/
delete_garbage(&unreachable, old);
/* Collect statistics on uncollectable objects found and print
* debugging information. */
for (gc = finalizers.gc.gc_next;
gc != &finalizers;
gc = gc->gc.gc_next) {
n++;
if (debug & DEBUG_UNCOLLECTABLE)
debug_cycle("uncollectable", FROM_GC(gc));
}
if (debug & DEBUG_STATS) {
if (m == 0 && n == 0)
PySys_WriteStderr("gc: done.\n");
else
PySys_WriteStderr(
"gc: done, "
"%" PY_FORMAT_SIZE_T "d unreachable, "
"%" PY_FORMAT_SIZE_T "d uncollectable.\n",
n+m, n);
}
/* Append instances in the uncollectable set to a Python
* reachable list of garbage. The programmer has to deal with
* this if they insist on creating this type of structure.
*/
(void)handle_finalizers(&finalizers, old);
if (PyErr_Occurred()) {
if (gc_str == NULL)
gc_str = PyString_FromString("garbage collection");
PyErr_WriteUnraisable(gc_str);
Py_FatalError("unexpected exception during garbage collection");
}
return n+m;
}
static void gevent_loop() {
if (!uwsgi.has_threads && uwsgi.mywid == 1) {
uwsgi_log("!!! Running gevent without threads IS NOT recommended, enable them with --enable-threads !!!\n");
}
if (uwsgi.shared->options[UWSGI_OPTION_SOCKET_TIMEOUT] < 30) {
uwsgi_log("!!! Running gevent with a socket-timeout lower than 30 seconds is not recommended, tune it with --socket-timeout !!!\n");
}
// get the GIL
UWSGI_GET_GIL
up.gil_get = gil_gevent_get;
up.gil_release = gil_gevent_release;
uwsgi.wait_write_hook = uwsgi_gevent_wait_write_hook;
uwsgi.wait_read_hook = uwsgi_gevent_wait_read_hook;
struct uwsgi_socket *uwsgi_sock = uwsgi.sockets;
if (uwsgi.async < 2) {
uwsgi_log("the gevent loop engine requires async mode (--async <n>)\n");
exit(1);
}
uwsgi.current_wsgi_req = uwsgi_gevent_current_wsgi_req;
PyObject *gevent_dict = get_uwsgi_pydict("gevent");
if (!gevent_dict) uwsgi_pyexit;
PyObject *gevent_version = PyDict_GetItemString(gevent_dict, "version_info");
if (!gevent_version) uwsgi_pyexit;
if (PyInt_AsLong(PyTuple_GetItem(gevent_version, 0)) < 1) {
uwsgi_log("uWSGI requires at least gevent 1.x version\n");
exit(1);
}
ugevent.spawn = PyDict_GetItemString(gevent_dict, "spawn");
if (!ugevent.spawn) uwsgi_pyexit;
ugevent.signal = PyDict_GetItemString(gevent_dict, "signal");
if (!ugevent.signal) uwsgi_pyexit;
ugevent.greenlet_switch = PyDict_GetItemString(gevent_dict, "sleep");
if (!ugevent.greenlet_switch) uwsgi_pyexit;
ugevent.greenlet_switch_args = PyTuple_New(0);
Py_INCREF(ugevent.greenlet_switch_args);
PyObject *gevent_get_hub = PyDict_GetItemString(gevent_dict, "get_hub");
ugevent.hub = python_call(gevent_get_hub, PyTuple_New(0), 0, NULL);
if (!ugevent.hub) uwsgi_pyexit;
ugevent.get_current = PyDict_GetItemString(gevent_dict, "getcurrent");
if (!ugevent.get_current) uwsgi_pyexit;
ugevent.get_current_args = PyTuple_New(0);
Py_INCREF(ugevent.get_current_args);
ugevent.hub_loop = PyObject_GetAttrString(ugevent.hub, "loop");
if (!ugevent.hub_loop) uwsgi_pyexit;
// main greenlet waiting for connection (one greenlet per-socket)
PyObject *uwsgi_gevent_main = PyCFunction_New(uwsgi_gevent_main_def, NULL);
Py_INCREF(uwsgi_gevent_main);
// greenlet to run at each request
PyObject *uwsgi_request_greenlet = PyCFunction_New(uwsgi_gevent_request_def, NULL);
Py_INCREF(uwsgi_request_greenlet);
// pre-fill the greenlet args
ugevent.greenlet_args = PyTuple_New(2);
PyTuple_SetItem(ugevent.greenlet_args, 0, uwsgi_request_greenlet);
if (uwsgi.signal_socket > -1) {
// and these are the watcher for signal sockets
ugevent.signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.signal_socket, 1);
if (!ugevent.signal_watcher) uwsgi_pyexit;
ugevent.my_signal_watcher = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi.my_signal_socket, 1);
if (!ugevent.my_signal_watcher) uwsgi_pyexit;
PyObject *uwsgi_greenlet_signal = PyCFunction_New(uwsgi_gevent_signal_def, NULL);
Py_INCREF(uwsgi_greenlet_signal);
PyObject *uwsgi_greenlet_my_signal = PyCFunction_New(uwsgi_gevent_my_signal_def, NULL);
Py_INCREF(uwsgi_greenlet_my_signal);
PyObject *uwsgi_greenlet_signal_handler = PyCFunction_New(uwsgi_gevent_signal_handler_def, NULL);
Py_INCREF(uwsgi_greenlet_signal_handler);
ugevent.signal_args = PyTuple_New(2);
PyTuple_SetItem(ugevent.signal_args, 0, uwsgi_greenlet_signal_handler);
// start the two signal watchers
if (!PyObject_CallMethod(ugevent.signal_watcher, "start", "O", uwsgi_greenlet_signal)) uwsgi_pyexit;
if (!PyObject_CallMethod(ugevent.my_signal_watcher, "start", "O", uwsgi_greenlet_my_signal)) uwsgi_pyexit;
}
// start a greenlet for each socket
ugevent.watchers = uwsgi_malloc(sizeof(PyObject *) * uwsgi_count_sockets(uwsgi.sockets));
int i = 0;
while(uwsgi_sock) {
// this is the watcher for server socket
ugevent.watchers[i] = PyObject_CallMethod(ugevent.hub_loop, "io", "ii", uwsgi_sock->fd, 1);
if (!ugevent.watchers[i]) uwsgi_pyexit;
// start the main greenlet
PyObject_CallMethod(ugevent.watchers[i], "start", "Ol", uwsgi_gevent_main,(long)uwsgi_sock);
uwsgi_sock = uwsgi_sock->next;
i++;
}
// patch goodbye_cruel_world
uwsgi.gbcw_hook = uwsgi_gevent_gbcw;
// map SIGHUP with gevent.signal
PyObject *ge_signal_tuple = PyTuple_New(2);
PyTuple_SetItem(ge_signal_tuple, 0, PyInt_FromLong(SIGHUP));
PyObject *uwsgi_gevent_unix_signal_handler = PyCFunction_New(uwsgi_gevent_unix_signal_handler_def, NULL);
Py_INCREF(uwsgi_gevent_unix_signal_handler);
PyTuple_SetItem(ge_signal_tuple, 1, uwsgi_gevent_unix_signal_handler);
python_call(ugevent.signal, ge_signal_tuple, 0, NULL);
for(;;) {
if (!PyObject_CallMethod(ugevent.hub, "join", NULL)) {
PyErr_Print();
}
else {
break;
}
}
if (uwsgi.workers[uwsgi.mywid].manage_next_request == 0) {
uwsgi_log("goodbye to the gevent Hub on worker %d (pid: %d)\n", uwsgi.mywid, uwsgi.mypid);
if (ugevent.destroy) {
exit(0);
}
exit(UWSGI_RELOAD_CODE);
}
uwsgi_log("the gevent Hub is no more :(\n");
}
static PyObject *
pcap_PcapObject_read(PyObject *p)
{
pcap_PcapObject *self = (pcap_PcapObject *)p;
struct pcap_pkthdr *hdr;
PyObject *pTmp = NULL;
PyObject *pBuf = NULL;
PyObject *pRet = NULL;
attempt {
if ('r' != self->mode) {
PyErr_Format(PyExc_IOError, "can not read from writable stream");
break;
}
pTmp = PyObject_CallMethod(self->pFile, "read", "i", sizeof(*hdr));
if (! pTmp) break;
{
char *buf;
int len;
int tmp;
tmp = PyString_AsStringAndSize(pTmp, &buf, &len);
if (-1 == tmp) {
break;
}
/* 0 bytes means end of file */
if (0 == len) {
pRet = Py_None;
Py_INCREF(pRet);
succeed;
}
if (len != sizeof(*hdr)) {
PyErr_Format(PyExc_IOError, "Read returned wrong number of bytes (%d)", len);
break;
}
/* Since buf points to something Python owns, we can just make hdr
point there and let buf fall off the stack. */
hdr = (struct pcap_pkthdr *)buf;
}
pBuf = PyObject_CallMethod(self->pFile, "read", "i", sl(hdr->caplen));
if (! pBuf) break;
pRet = Py_BuildValue("(lll)O",
sl(hdr->ts.tv_sec),
sl(hdr->ts.tv_usec),
sl(hdr->len),
pBuf);
if (! pRet) break;
}
Py_CLEAR(pTmp);
Py_CLEAR(pBuf);
recover {
Py_CLEAR(pRet);
return NULL;
}
return pRet;
}
int pcmreader_read(struct pcmreader_s* reader,
unsigned pcm_frames,
aa_int* channels)
{
PyObject* framelist_obj;
pcm_FrameList* framelist;
unsigned frame;
unsigned channel;
a_int* channel_a;
struct pcmreader_callback* callback;
PyObject* string_obj;
unsigned char* string;
Py_ssize_t string_length;
/*make a call to "pcmreader.read(pcm_frames)"
where "pcm_frames" is set to the proper PCM frame count*/
if (((framelist_obj =
PyObject_CallMethod(reader->pcmreader_obj, "read", "i",
(int)pcm_frames))) == NULL) {
/*ensure result isn't an exception*/
return 1;
}
/*ensure result is a pcm.FrameList object*/
if (framelist_obj->ob_type != (PyTypeObject*)reader->framelist_type) {
Py_DECREF(framelist_obj);
PyErr_SetString(PyExc_TypeError,
"results from pcmreader.read() must be FrameLists");
return 1;
} else {
framelist = (pcm_FrameList*)framelist_obj;
}
/*split framelist's packed ints into a set of channels*/
channels->reset(channels);
for (channel = 0; channel < framelist->channels; channel++) {
channel_a = channels->append(channels);
channel_a->resize(channel_a, framelist->frames);
for (frame = 0; frame < framelist->frames; frame++) {
a_append(channel_a,
framelist->samples[(frame * framelist->channels) +
channel]);
}
}
/*apply all callbacks to pcm.FrameList object*/
for (callback = reader->callbacks;
callback != NULL;
callback = callback->next) {
string_obj = PyObject_CallMethod(framelist_obj,
"to_bytes", "(ii)",
!callback->little_endian,
callback->is_signed);
if (string_obj == NULL) {
Py_DECREF(framelist_obj);
return 1;
}
if (PyString_AsStringAndSize(string_obj,
(char**)(&string),
&string_length) == -1) {
Py_DECREF(framelist_obj);
Py_DECREF(string_obj);
return 1;
}
callback->callback(callback->user_data,
string,
(unsigned long)string_length);
Py_DECREF(string_obj);
}
/*free any allocated buffers and Python objects*/
Py_DECREF(framelist_obj);
return 0;
}
static PyObject *PyPCAP_next(PyPCAP *self) {
PyObject *result;
int len;
int packet_offset;
// Make sure our buffer is full enough:
if(self->buffer->size - self->buffer->readptr < MAX_PACKET_SIZE) {
len = PyPCAP_fill_buffer(self, self->fd);
if(len<0) return NULL;
};
packet_offset = self->buffer->readptr;
/** This is an interesting side effect of the talloc reference model:
talloc_reference(context, ptr) adds a new context to ptr so ptr is
now effectively parented by two parents. The two parents are not
equal however because a talloc free(ptr) will remove the reference
first and then the original parent.
This causes problems here because we create the packet_header with
self->buffer as a context. However other code takes references to it
- pinning it to other parents. If we did a
talloc_free(self->packet_header) here we would be removing those
references _instead_ of freeing the ptr from our own self->buffer
reference. This will cause both memory leaks (because we will not be
freeing packet_header at all, and later crashes because important
references will be removed.
When references begin to be used extensively I think we need to
start using talloc_unlink instead of talloc_free everywhere.
*/
// Free old packets:
if(self->packet_header)
talloc_unlink(self->buffer, self->packet_header);
// Make a new packet:
self->packet_header = (PcapPacketHeader)CONSTRUCT(PcapPacketHeader, Packet,
super.Con, self->buffer, NULL);
if(self->file_header->little_endian) {
self->packet_header->super.format = self->packet_header->le_format;
};
// Read the packet in:
len = self->packet_header->super.Read((Packet)self->packet_header, self->buffer);
// Did we finish?
if(len<=0) {
return PyErr_Format(PyExc_StopIteration, "Done");
};
// Make sure the new packet knows its offset and where it came from:
self->packet_header->header.offset = self->pcap_offset;
self->packet_header->header.pcap_file_id = self->pcap_file_id;
// Keep track of our own file offset:
self->pcap_offset += self->buffer->readptr - packet_offset;
// CALL(self->buffer, skip, self->buffer->readptr);
// Adjust the output endianess if needed
switch(self->output_format) {
case FORCE_BIG_ENDIAN:
// FIXME - Leaks!!!
self->packet_header->super.format = PCAP_PKTHEADER_STRUCT;
break;
case FORCE_LITTLE_ENDIAN:
self->packet_header->super.format = PCAP_PKTHEADER_STRUCT_LE;
break;
default:
// Do nothing
break;
};
// create a new pypacket object:
result = PyObject_CallMethod(g_pypacket_module, "PyPacket", "N",
PyCObject_FromVoidPtr(self->packet_header,NULL), "PcapPacketHeader");
return result;
};
boost::python::object GCHMCIntegrator::Call(
int nosteps_arg,
int steps_per_trial_arg,
TARGET_TYPE temp_arg,
TARGET_TYPE ts,
int pyseed,
int _massMatNumOpt, // EU
int _metroFixmanOpt, // EU
double _lj14sf //--
){
#ifdef DEBUG_TIME
//boost::timer boost_timer;
#endif
int ntrials_arg = 0;
if(nosteps_arg%steps_per_trial_arg){
fprintf(stderr,
"GCHMCIntegrator::Call(): Incorrect nosteps/steps_per_trial combination: %d/%d\n",
nosteps_arg, steps_per_trial_arg);
exit(1);
}
ntrials_arg = nosteps_arg/steps_per_trial_arg;
int tx, tshm;
boost::python::list booConfList;
int i, j;
double **retConfsPois = new double* [ntrials_arg];
double *retPotEsPoi = new double[ntrials_arg];
double *accs = new double;
*accs = 0.0;
vector3 *xCall;
PyObject *SrcConfObj = PyObject_CallMethod(this->universe, "copyConfiguration", NULL);
// START GET CURR CONF
PyObject *CallConfArr = PyObject_GetAttrString(SrcConfObj, "array");
PyArrayObject *CallConfiguration = (PyArrayObject *)CallConfArr;
xCall = (vector3 *)CallConfiguration->data;
// STOP GET CURR CONF
PyObject *ConfObjs[ntrials_arg];
PyObject *ConfArrs[ntrials_arg];
PyArrayObject *Confs[ntrials_arg];
boost::python::object booConfObjs[ntrials_arg];
boost::python::list booPotEs;
for(i=0; i<ntrials_arg; i++){
ConfObjs[i] = PyObject_CallMethod(this->universe, "copyConfiguration", NULL);
ConfArrs[i] = PyObject_GetAttrString(ConfObjs[i], "array");
Confs[i] = (PyArrayObject *)(ConfArrs[i]);
retConfsPois[i] = (double *)(Confs[i])->data;
}
// Put curr conf from universe into shm
for(int a=0; a<sys->mr->natms; a++){
tx = (int)(sys->indexMap[ a ][2]);
tshm = ((int)(sys->indexMap[ a ][1]) * 3) + 2;
shm[ tshm +0] = xCall[tx][0];
shm[ tshm +1] = xCall[tx][1];
shm[ tshm +2] = xCall[tx][2];
}
*sys->pyseed = pyseed;
sys->massMatNumOpt = _massMatNumOpt; // EU
sys->metroFixmanOpt = _metroFixmanOpt; // EU
sys->lj14sf = _lj14sf; //--
sys->sysRetConfsPois = retConfsPois;
sys->sysRetPotEsPoi = retPotEsPoi;
sys->sysAccs = accs;
if(nosteps_arg % ntrials_arg){
fprintf(stderr, "nosteps_arg % ntrials_arg not 0\n");
exit(1);
}
this->nosteps = nosteps_arg;
this->ntrials = ntrials_arg;
this->temperature = temp_arg;
this->delta_t = ts;
++(this->sweep);
int arrays_cut = 2 + 4*3*(sys->mr->natms);
shm[arrays_cut + 0] = 0.0; // step (will be incremented in MidVV
shm[arrays_cut + 1] = (TARGET_TYPE)(this->nosteps);
shm[arrays_cut + 2] = this->temperature;
shm[arrays_cut + 3] = delta_t; // picosec
shm[arrays_cut + 7] = 1.0; // acceptance always 1 !!
shm[arrays_cut + 9] = nosteps/ntrials; // steps_per_trial
shm[arrays_cut + 10] = 0.0; // initialize trial
// * Get <Universe>'s pyo_evaluator //
PyObject *pyo_evaluator;
PyObject *cpyo_evaluator;
pyo_evaluator = PyObject_CallMethod(this->universe, "energyEvaluator", NULL);
cpyo_evaluator = PyObject_CallMethod(pyo_evaluator, "CEvaluator", NULL);
this->evaluator = (PyFFEvaluatorObject *)cpyo_evaluator;
sys->evaluator = this->evaluator;
#ifdef DEBUG_TIME
//std::cout<<"Time simmain nosteps"<<this->nosteps<<" time "<<boost_timer.elapsed()<<std::endl;
#endif
sys->Advance(this->nosteps);
#ifdef DEBUG_TIME
//std::cout<<"Time simmain nosteps"<<this->nosteps<<" time "<<boost_timer.elapsed()<<std::endl;
#endif
xCall = (vector3 *)configuration->data;
for(int a=0; a<sys->mr->natms; a++){
tx = (int)(sys->indexMap[ a ][2]);
tshm = ((int)(sys->indexMap[ a ][1]) * 3) + 2;
xCall[tx][0] = shm[ tshm +0];
xCall[tx][1] = shm[ tshm +1];
xCall[tx][2] = shm[ tshm +2];
}
for(i=0; i<ntrials_arg; i++){
booConfObjs[i] = boost::python::object(boost::python::handle<>( boost::python::borrowed((PyObject *)(ConfObjs[i])) ));
booConfList.append(booConfObjs[i]);
booPotEs.append(retPotEsPoi[i]); // potential energies
}
double ntrials = (shm[arrays_cut + 1]) / (shm[arrays_cut + 9]);
double booAccPerTrials = *accs / ntrials; //float(acc)/float(ntrials)
boost::python::list booRetList;
booRetList.append(booConfList);
booRetList.append(booPotEs);
//booRetList.append(booAccPerTrials); // RESTORE
booRetList.append(int(*accs));
booRetList.append(int(ntrials));
booRetList.append(ts); // delta_t
delete accs;
return booRetList; // (xs, energies, acc, ntrials, delta_t)
}
