double getTime(TString logfile, TString module) {
gSystem->Exec("grep TimeReport "+logfile+" | grep "+module+" | tail -1 >& tmp1.log");
gSystem->Exec("echo >> tmp1.log");
ifstream inlimits("tmp1.log");
string line;
double imas = 0;
if (inlimits.is_open()) {
while ( inlimits.good() ) {
getline (inlimits,line);
TString myline(line);
if ((*myline.Tokenize(' ')).GetEntries()<8) continue;
TString value( ((TObjString*) (*myline.Tokenize(' '))[5])->GetString().Data() );
imas = value.Atof();
//cout << line << endl;
}
inlimits.close();
}
gSystem->Exec("rm tmp1.log");
//cout << "inlimits.is_open(): " << inlimits.is_open() << endl;
//cout<<"returning: " << imas << endl;
return imas;
}
static store_error_t store_get_span(const store_t *store, uint64_t irecord,
int32_t *itmin, int32_t *nsamples, int *is_zero) {
record_t *record;
if (irecord >= store->nrecords) {
return INVALID_RECORD;
}
record = &store->records[irecord];
*itmin = xe32toh(record->itmin);
*nsamples = xe32toh(record->nsamples);
*is_zero = REC_ZERO == xe64toh(record->data_offset);
if (!inlimits(*itmin) || !inposlimits(*nsamples)) {
return BAD_RECORD;
}
return SUCCESS;
}
static PyObject* w_store_get(PyObject *dummy, PyObject *args) {
PyObject *capsule;
uint64_t irecord;
store_t *store;
gf_dtype *adata;
trace_t trace;
PyArrayObject *array = NULL;
npy_intp array_dims[1] = {0};
int32_t itmin;
int32_t nsamples;
int i;
store_error_t err;
(void)dummy; /* silence warning */
if (!PyArg_ParseTuple(args, "OKii", &capsule, &irecord, &itmin, &nsamples)) {
PyErr_SetString(StoreExtError, "usage store_get(cstore, irecord, itmin, nsamples)");
return NULL;
}
#ifdef HAVE_CAPSULE
if (!PyCapsule_IsValid(capsule, NULL)) {
#else
if (!PyCObject_Check(capsule)) {
#endif
PyErr_SetString(StoreExtError, "invalid cstore argument");
return NULL;
}
if (!inlimits(itmin)) {
PyErr_SetString(StoreExtError, "invalid itmin argument");
return NULL;
}
if (!(inposlimits(nsamples) || -1 == nsamples)) {
PyErr_SetString(StoreExtError, "invalid nsamples argument");
return NULL;
}
#ifdef HAVE_CAPSULE
store = (store_t*)PyCapsule_GetPointer(capsule, NULL);
#else
store = (store_t*)PyCObject_AsVoidPtr(capsule);
#endif
err = store_get(store, irecord, &trace);
if (SUCCESS != err) {
PyErr_SetString(StoreExtError, store_error_names[err]);
return NULL;
}
if (-1 != nsamples) {
trace_trim(&trace, itmin, nsamples);
}
array_dims[0] = trace.nsamples;
array = (PyArrayObject*)PyArray_EMPTY(1, array_dims, NPY_FLOAT32, 0);
adata = (gf_dtype*)PyArray_DATA(array);
for (i=0; i<trace.nsamples; i++) {
adata[i] = fe32toh(trace.data[i]);
}
return Py_BuildValue("Nififf", array, trace.itmin, store->deltat,
trace.is_zero, trace.begin_value, trace.end_value);
}
static PyObject* w_store_sum(PyObject *dummy, PyObject *args) {
PyObject *capsule, *irecords_arr, *delays_arr, *weights_arr;
store_t *store;
gf_dtype *adata;
trace_t result;
PyArrayObject *array = NULL;
npy_intp array_dims[1] = {0};
PyArrayObject *c_irecords_arr, *c_delays_arr, *c_weights_arr;
uint64_t *irecords;
float32_t *delays, *weights;
npy_intp n, n1, n2;
int32_t itmin;
int32_t nsamples;
store_error_t err;
(void)dummy; /* silence warning */
if (!PyArg_ParseTuple(args, "OOOOii", &capsule, &irecords_arr, &delays_arr,
&weights_arr, &itmin, &nsamples)) {
PyErr_SetString(StoreExtError,
"usage: store_sum(cstore, irecords, delays, weights, itmin, nsamples)");
return NULL;
}
#ifdef HAVE_CAPSULE
if (!PyCapsule_IsValid(capsule, NULL)) {
#else
if (!PyCObject_Check(capsule)) {
#endif
PyErr_SetString(StoreExtError, "invalid cstore argument");
return NULL;
}
if (!PyArray_Check(irecords_arr) ||
NPY_UINT64 != PyArray_TYPE((PyArrayObject*)irecords_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'irecords' must be a NumPy array of type uint64");
return NULL;
}
if (!PyArray_Check(delays_arr) ||
NPY_FLOAT32 != PyArray_TYPE((PyArrayObject*)delays_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'delays' must be a NumPy array of type float32");
return NULL;
}
if (!PyArray_Check(weights_arr) ||
NPY_FLOAT32 != PyArray_TYPE((PyArrayObject*)weights_arr)) {
PyErr_SetString(StoreExtError,
"store_sum: 'weights' must be a NumPy array of type float32");
return NULL;
}
if (!inlimits(itmin)) {
PyErr_SetString(StoreExtError, "invalid itmin argument");
return NULL;
}
if (!(inposlimits(nsamples) || -1 == nsamples)) {
PyErr_SetString(StoreExtError, "invalid nsamples argument");
return NULL;
}
#ifdef HAVE_CAPSULE
store = (store_t*)PyCapsule_GetPointer(capsule, NULL);
#else
store = (store_t*)PyCObject_AsVoidPtr(capsule);
#endif
c_irecords_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)irecords_arr);
c_delays_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)delays_arr);
c_weights_arr = PyArray_GETCONTIGUOUS((PyArrayObject*)weights_arr);
n = PyArray_SIZE(c_irecords_arr);
n1 = PyArray_SIZE(c_delays_arr);
n2 = PyArray_SIZE(c_weights_arr);
if (n != n1 || n != n2) {
PyErr_SetString(StoreExtError,
"store_sum: 'irecords', 'delays', and 'weights' must have same length");
return NULL;
}
irecords = PyArray_DATA(c_irecords_arr);
delays = PyArray_DATA(c_delays_arr);
weights = PyArray_DATA(c_weights_arr);
err = store_sum(store, irecords, delays, weights, n, itmin, nsamples, &result);
if (SUCCESS != err) {
PyErr_SetString(StoreExtError, store_error_names[err]);
return NULL;
}
Py_DECREF(c_irecords_arr);
Py_DECREF(c_delays_arr);
Py_DECREF(c_weights_arr);
array_dims[0] = result.nsamples;
array = (PyArrayObject*)PyArray_EMPTY(1, array_dims, NPY_FLOAT32, 0);
adata = (gf_dtype*)PyArray_DATA(array);
memcpy(adata, result.data, result.nsamples*sizeof(gf_dtype));
free(result.data);
return Py_BuildValue("Nififf", array, result.itmin, store->deltat,
result.is_zero, result.begin_value, result.end_value);
}
static PyMethodDef StoreExtMethods[] = {
{"store_init", w_store_init, METH_VARARGS,
"Initialize store struct." },
{"store_get", w_store_get, METH_VARARGS,
"Get a GF trace." },
{"store_sum", w_store_sum, METH_VARARGS,
"Get weight-and-delay-sum of GF traces." },
{NULL, NULL, 0, NULL} /* Sentinel */
};
PyMODINIT_FUNC
initstore_ext(void)
{
PyObject *m;
m = Py_InitModule("store_ext", StoreExtMethods);
if (m == NULL) return;
import_array();
StoreExtError = PyErr_NewException("store_ext.error", NULL, NULL);
Py_INCREF(StoreExtError); /* required, because other code could remove `error`
from the module, what would create a dangling
pointer. */
PyModule_AddObject(m, "StoreExtError", StoreExtError);
}
static store_error_t store_sum(
const store_t *store,
const uint64_t *irecords,
const float32_t *delays,
const float32_t *weights,
int32_t n,
int32_t itmin,
int32_t nsamples,
trace_t *result) {
int32_t itmax;
int is_zero;
float itmin_d, itmax_d;
float32_t weight, delay;
trace_t trace;
float32_t deltat = store->deltat;
gf_dtype begin_value, end_value;
gf_dtype *out;
int ilo;
/*int32_t ifloor, iceil;*/
int i, j;
int idelay_floor, idelay_ceil;
int ihave;
float w1, w2;
store_error_t err;
*result = ZERO_TRACE;
if (0 == n) {
return SUCCESS;
}
if (-1 == nsamples) {
itmin_d = itmax_d = 0.;
ihave = 0;
for (j=0; j<n; j++) {
err = store_get_span(store, irecords[j], &itmin, &nsamples, &is_zero);
if (SUCCESS != err) {
return err;
}
itmax = itmin + nsamples - 1;
if (ihave) {
itmin_d = min(itmin_d, itmin + delays[j]/deltat);
itmax_d = max(itmax_d, itmax + delays[j]/deltat);
}
else {
itmin_d = itmin + delays[j]/deltat;
itmax_d = itmax + delays[j]/deltat;
ihave = 1;
}
}
itmin = floor(itmin_d);
nsamples = ceil(itmax_d) - itmin + 1;
}
if (!inlimits(itmin) || !inposlimits(nsamples)) {
return BAD_REQUEST;
}
out = NULL;
if (0 != nsamples) {
out = (gf_dtype*)calloc(nsamples, sizeof(gf_dtype));
if (out == NULL) {
return ALLOC_FAILED;
}
}
begin_value = 0.0;
end_value = 0.0;
for (j=0; j<n; j++) {
delay = delays[j];
weight = weights[j];
idelay_floor = (int)floor(delay/deltat);
idelay_ceil = (int)ceil(delay/deltat);
if (!inlimits(idelay_floor) || !inlimits(idelay_ceil)) {
free(out);
return BAD_REQUEST;
}
if (0.0 == weight) {
continue;
}
err = store_get(store, irecords[j], &trace);
if (SUCCESS != err) {
free(out);
return err;
}
if (trace.is_zero) {
continue;
}
trace_trim_sticky(&trace, itmin - idelay_ceil, nsamples + idelay_ceil - idelay_floor);
if (idelay_floor == idelay_ceil) {
ilo = itmin - idelay_floor - trace.itmin;
/*for (i=0; i<nsamples; i++) {
ifloor = i + ilo;
ifloor = max(0, min(ifloor, trace.nsamples-1));
out[i] += fe32toh(trace.data[ifloor]) * weight;
} // version below is a bit faster */
for (i=0; i<min(-ilo,nsamples); i++) {
out[i] += fe32toh(trace.data[0]) * weight;
}
for (i=max(0,-ilo); i<min(nsamples, trace.nsamples-ilo); i++) {
out[i] += fe32toh(trace.data[i+ilo]) * weight;
}
for (i=max(0,trace.nsamples-ilo); i<nsamples; i++) {
out[i] += fe32toh(trace.data[trace.nsamples-1]) * weight;
}
} else {
ilo = itmin - idelay_floor - trace.itmin;
/*ihi = ilo - 1;*/
w1 = (idelay_ceil - delay/deltat) * weight;
w2 = (delay/deltat - idelay_floor) * weight;
/*for (i=0; i<nsamples; i++) {
ifloor = i + ilo;
iceil = i + ihi;
ifloor = max(0, min(ifloor, trace.nsamples-1));
iceil = max(0, min(iceil, trace.nsamples-1));
out[i] += fe32toh(trace.data[ifloor]) * w1;
out[i] += fe32toh(trace.data[iceil]) * w2;
} // version below is a bit faster */
for (i=0; i<min(-ilo,nsamples); i++) {
out[i] += fe32toh(trace.data[0]) * weight;
}
for (i=max(0,-ilo); i<min(nsamples, -ilo+1); i++) {
out[i] += fe32toh(trace.data[i+ilo])*w1
+ fe32toh(trace.data[0])*w2;
}
for (i=max(0,-ilo+1); i<min(nsamples, trace.nsamples-ilo); i++) {
out[i] += fe32toh(trace.data[i+ilo])*w1
+ fe32toh(trace.data[i+ilo-1])*w2;
}
for (i=max(0,trace.nsamples-ilo);
i<min(nsamples, trace.nsamples-ilo+1); i++) {
out[i] += fe32toh(trace.data[trace.nsamples-1]) * w1
+ fe32toh(trace.data[i+ilo-1])*w2;
}
for (i=max(0,trace.nsamples-ilo+1); i<nsamples; i++) {
out[i] += fe32toh(trace.data[trace.nsamples-1]) * weight;
}
}
begin_value += trace.begin_value * weight;
end_value += trace.end_value * weight;
}
result->is_zero = 0;
result->itmin = itmin;
result->nsamples = nsamples;
result->begin_value = begin_value;
result->end_value = end_value;
result->data = out;
return SUCCESS;
}
static store_error_t store_get(
const store_t *store,
uint64_t irecord,
trace_t *trace) {
record_t *record;
uint64_t data_offset;
store_error_t err;
size_t nbytes;
if (irecord >= store->nrecords) {
*trace = ZERO_TRACE;
return INVALID_RECORD;
}
record = &store->records[irecord];
data_offset = xe64toh(record->data_offset);
trace->itmin = xe32toh(record->itmin);
trace->nsamples = xe32toh(record->nsamples);
trace->begin_value = fe32toh(record->begin_value);
trace->end_value = fe32toh(record->end_value);
if (!inlimits(trace->itmin) || !inposlimits(trace->nsamples) ||
data_offset >= UINT64_MAX - SLIMIT * sizeof(gf_dtype)) {
return BAD_RECORD;
}
if (REC_EMPTY == data_offset) {
*trace = ZERO_TRACE;
return EMPTY_RECORD;
}
if (REC_ZERO == data_offset) {
*trace = ZERO_TRACE;
trace->itmin = xe32toh(record->itmin);
return SUCCESS;
}
trace->is_zero = 0;
if (data_offset + trace->nsamples*sizeof(gf_dtype) > store->data_size) {
*trace = ZERO_TRACE;
return BAD_DATA_OFFSET;
}
if (REC_SHORT == data_offset) {
trace->data = &record->begin_value;
} else {
if (NULL != store->data) {
trace->data = &store->data[data_offset/sizeof(gf_dtype)];
} else {
if (NULL == store->memdata[irecord]) {
nbytes = trace->nsamples * sizeof(gf_dtype);
store->memdata[irecord] = (gf_dtype*)malloc(nbytes);
if (NULL == store->memdata[irecord]) {
*trace = ZERO_TRACE;
return ALLOC_FAILED;
}
err = store_read(store, data_offset, nbytes, store->memdata[irecord]);
if (SUCCESS != err) {
free(store->memdata[irecord]);
store->memdata[irecord] = NULL;
*trace = ZERO_TRACE;
return err;
}
}
trace->data = store->memdata[irecord];
}
}
return SUCCESS;
}
