void read_binary(const std::string &filename, int n_cols, int *n_rows,
float **values)
{
std::ifstream in(filename.c_str(), std::ios::binary);
if (!in)
throw std::runtime_error("File '" + filename + "' can't be opened.");
in.seekg(0, in.end); // jump to the end of the file
int length = in.tellg(); // total length of the file in bytes
int n_values = length / sizeof(float); // number of values
*n_rows = n_values / n_cols; // number of rows of the matrix in the binary file
if (length % sizeof(float) != 0)
throw std::runtime_error("The number of bytes in the file '" + filename +
"' is not divisible by " + d2s(sizeof(float)));
if (n_values % n_cols != 0)
throw std::runtime_error("The number of values in the file '" + filename +
"' is not divisible by the number of columns " +
d2s(n_cols));
in.seekg(0, in.beg); // jump to the beginning of the file
*values = new float[n_values];
in.read(reinterpret_cast<char*>(*values), length); // read all at once
if(length != static_cast<int>(in.gcount()))
throw std::runtime_error("The number of successfully read bytes (" +
d2s(in.gcount()) + ") is different from the "
"expected one (" + d2s(length) + ")");
}
void window::updateResults(double aprox, double bee) {
working = false;
widget.resultAprox->setText(d2s(aprox));
widget.resultBee->setText(d2s(bee));
widget.startButton->setEnabled(true);
widget.stopButton->setEnabled(false);
}
void get_properties(const std::string &filename,
std::map<int, std::vector<double> > &properties)
{
std::cout << "Getting properties..." << std::endl;
double t_begin = get_wall_time();
std::ifstream in(filename.c_str());
require(in, "File " + filename + " can't be opened");
int materialID;
std::vector<double> values;
int n_values = 0; // default value
std::string line;
while (getline(in, line)) // read the file line-by-line
{
// if the line is empty or starts with '#' (a comment), we skip it
if (line.empty() || line[0] == '#') continue;
values.clear();
if (n_values == 0) // first run
values.reserve(10); // we don't expect more than 10 parameters by default
else
values.reserve(n_values);
std::istringstream instr(line);
instr >> materialID;
double val;
while (instr >> val)
values.push_back(val);
if (n_values == 0)
n_values = values.size();
else
require(n_values == (int)values.size(), "The number of parameters in the "
"first appearance was " + d2s(n_values) + ", but in some line "
"there are " + d2s(values.size()) + " of them");
// insert the vector into the map
std::pair<std::map<int, std::vector<double> >::const_iterator, bool> res =
properties.insert(std::pair<int, std::vector<double> >(materialID, values));
// check that the insertion was successfull
require(res.second, "Insertion of the values for the material with ID =" +
d2s(materialID) + " failed. Check the data (file = " + filename +
")");
}
in.close();
std::cout << "Getting properties is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
int RectangularMesh::find_element(const Point2 &point,
bool throw_exception) const
{
const double px = point.x(); // coordinates of the point of interest
const double pz = point.z();
const double x0 = _min_coord.x(); // limits of the rect mesh
const double x1 = _max_coord.x();
const double z0 = _min_coord.z();
const double z1 = _max_coord.z();
// check that the point is within the mesh
const double tol = FIND_CELL_TOLERANCE;
if (px < x0 - tol || px > x1 + tol ||
pz < z0 - tol || pz > z1 + tol)
{
if (throw_exception)
require(false, "The given point " + d2s(point) + " doesn't belong "
"to the rectangular mesh");
return -1; // to show that the point in not here
}
// since the elements of the rectangular mesh are numerated in the following
// way:
// -----------
// | 0 | 1 |
// -----------
// | 2 | 3 |
// -----------
// we can simplify the search of the element containing the given point:
const double hx = (x1 - x0) / _n_elements_x;
const double hz = (z1 - z0) / _n_elements_z;
const int nx = std::min(static_cast<int>((px-x0)/hx), _n_elements_x-1);
const int nz = std::min(static_cast<int>((pz-z0)/hz), _n_elements_z-1);
if (nx < 0 || nx >= _n_elements_x ||
nz < 0 || nz >= _n_elements_z)
{
if (throw_exception)
require(false, "The rectangular element for the point " + d2s(point) +
" wasn't found");
return -1; // to show that the point in not here
}
return (nz*_n_elements_x + nx);
}
void RectangularMesh::
write_binary_files_in_cells(const std::string &prop_filename,
std::vector<std::string> &filenames_out) const
{
std::cout << "Writing binary files in cells..." << std::endl;
double t_begin = get_wall_time();
// Create the map between the material IDs and the media properties. The
// material IDs must exactly the same as in the given triangular mesh.
std::map<int, std::vector<double> > properties;
get_properties(prop_filename, properties);
const int n_properties = properties.begin()->second.size();
filenames_out.resize(n_properties);
std::ofstream *out = new std::ofstream[n_properties];
for (int i = 0; i < n_properties; ++i)
{
filenames_out[i] = "property" + d2s(i) + "_cells.bin";
out[i].open(filenames_out[i].c_str(), std::ios::binary);
require(out[i], "File '" + filenames_out[i] + "' can't be opened");
}
for (int i = 0; i < _n_elements_x*_n_elements_z; ++i)
{
const int matID = _cells_ID[i];
std::map<int, std::vector<double> >::const_iterator iter =
properties.find(matID);
require(iter != properties.end(), "The material ID " + d2s(matID) +
" wasn't found in the properties file");
const std::vector<double> values = iter->second;
for (int p = 0; p < n_properties; ++p)
{
OUT_FLOAT_TYPE val = values[p];
out[p].write(reinterpret_cast<char*>(&val), sizeof(OUT_FLOAT_TYPE));
}
}
for (int i = 0; i < n_properties; ++i)
out[i].close();
delete[] out;
std::cout << "Writing binary files in cells is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
void initActors(){
for(int i=0; i<32*1024; i++){
twi64k[i].real = d2s(32768.5*cos(-2*M_PI*i/(64*1024)));
twi64k[i].imag = d2s(32768.5*sin(-2*M_PI*i/(64*1024)));
}
gen_twiddle_fft16x16_imre((short*)gen_twi32k, 32*1024);
gen_twiddle_fft16x16_imre((short*)gen_twi16k, 16*1024);
gen_twiddle_fft16x16_imre((short*)gen_twi8k, 8*1024);
gen_twiddle_fft16x16_imre((short*)gen_twi4k, 4*1024);
gen_twiddle_fft16x16_imre((short*)gen_twi2k, 2*1024);
gen_twiddle_fft16x16_imre((short*)gen_twi1k, 1024);
gen_twiddle_fft16x16_imre((short*)gen_twi512, 512);
gen_twiddle_fft16x16_imre((short*)gen_twi256, 256);
gen_twiddle_fft16x16_imre((short*)gen_twi128, 128);
}
/* ======================================================================== */
void d2s_vec(double *d_vec,short *s_vec, int n)
{
int i;
for(i=0;i<n;i++){
*(s_vec+i)= d2s(*(d_vec+i));
}
}
void RectangularMesh::
write_ASCII_files_at_nodes(const std::string &prop_filename) const
{
std::cout << "Writing ASCII files at nodes..." << std::endl;
double t_begin = get_wall_time();
// Create the map between the material IDs and the media properties. The
// material IDs must exactly the same as in the given triangular mesh.
std::map<int, std::vector<double> > properties;
get_properties(prop_filename, properties);
const int n_properties = properties.begin()->second.size();
std::vector<std::string> filenames_out(n_properties);
std::ofstream *out = new std::ofstream[n_properties];
for (int i = 0; i < n_properties; ++i)
{
filenames_out[i] = "property" + d2s(i) + "_nodes.txt";
out[i].open(filenames_out[i].c_str(), std::ios::binary);
require(out[i], "File '" + filenames_out[i] + "' can't be opened");
}
for (int i = 0; i < (_n_elements_x+1)*(_n_elements_z+1); ++i)
{
const int matID = _verts_ID[i];
std::map<int, std::vector<double> >::const_iterator iter =
properties.find(matID);
require(iter != properties.end(), "The material ID " + d2s(matID) +
" wasn't found in the properties file");
const std::vector<double> values = iter->second;
for (int p = 0; p < n_properties; ++p)
out[p] << values[p] << "\n";
}
for (int i = 0; i < n_properties; ++i)
out[i].close();
delete[] out;
std::cout << "Writing ASCII files at nodes is done. Time = "
<< get_wall_time() - t_begin << std::endl;
}
RectangularMesh::RectangularMesh(const Point2 &beg,
const Point2 &end,
int nx_,
int nz_)
: _min_coord(beg),
_max_coord(end),
_n_elements_x(nx_),
_n_elements_z(nz_),
_verts_ID(nullptr),
_cells_ID(nullptr)
{
require(_min_coord < _max_coord, "The max point of the mesh (" +
d2s(_max_coord) + ") must be bigger than the min point (" +
d2s(_min_coord) + ")");
require(_n_elements_x > 0, "The number of elements in x-direction (" +
d2s(_n_elements_x) + ") must be >0");
require(_n_elements_z > 0, "The number of elements in z-direction (" +
d2s(_n_elements_z) + ") must be >0");
}
void initActors2(){
double M = 32767.5;
// for(int i=0; i<64*1024; i++){
// twi64k[2*i ] = d2s(-M*sin(-2*M_PI*i/(64*1024))/2);
// twi64k[2*i+1] = d2s(M*cos(-2*M_PI*i/(64*1024))/2);
// }
// for(int i=0; i<64*1024; i++){
// twi64k[i].real = d2s(M*cos(-2*M_PI*i/(64*1024)));
// twi64k[i].imag = d2s(M*sin(-2*M_PI*i/(64*1024)));
// }
for(int r=0; r<256; r++){
for(int c=0; c<256; c++){
twi64k[r*256+c].real = d2s(M*cos(-2*M_PI*r*c/(64*1024))/2);
twi64k[r*256+c].imag = d2s(M*sin(-2*M_PI*r*c/(64*1024))/2);
}
}
// gen_twiddle_fft16x16(twi64k, 64*1024);
}
void read_binary(const std::string &filename, int n_values, double *values)
{
std::ifstream in(filename.c_str(), std::ios::binary);
if (!in)
throw std::runtime_error("File '" + filename + "' can't be opened.");
in.seekg(0, in.end); // jump to the end of the file
int length = in.tellg(); // total length of the file in bytes
int size_value = length / n_values; // size (in bytes) of one value
if (length % n_values != 0)
throw std::runtime_error("The number of bytes in the file '" + filename +
"' is not divisible by the number of elements " +
d2s(n_values));
in.seekg(0, in.beg); // jump to the beginning of the file
if (size_value == sizeof(double))
{
in.read((char*)values, n_values*size_value); // read all at once
if(n_values != static_cast<int>(in.gcount()))
throw std::runtime_error("The number of successfully read elements is "
"different from the expected one");
}
else if (size_value == sizeof(float))
{
float val;
for (int i = 0; i < n_values; ++i) // read element-by-element
{
in.read((char*)&val, size_value); // read a 'float' value
values[i] = val; // convert it to a 'double' value
}
}
else
throw std::runtime_error("Unknown size of an element (" + d2s(size_value) +
") in bytes. Expected one is either sizeof(float) "
"= " + d2s(sizeof(float)) + ", or sizeof(double) "
"= " + d2s(sizeof(double)));
}
//------------------------------------------------------------------------------
//
// Get an absolute path according to the given relative one
//
//------------------------------------------------------------------------------
std::string absolute_path(const std::string &rel_path)
{
#if defined(__linux__) || defined(__APPLE__)
char abs_path[PATH_MAX];
char *res = realpath(rel_path.c_str(), abs_path);
require(res != NULL, "The function realpath() failed with the input "
"(relative path) = '" + rel_path + "'. errno is set to " + d2s(errno)+
" which means '" + std::string(strerror(errno)) + "'");
return std::string(abs_path);
#else
require(false, "absolute_path() is not implemented for this OS");
#endif
}
void RectangularMesh::
assign_material_id_at_nodes(const TriangularMesh &tri_mesh)
{
double t0 = get_wall_time();
std::cout << "Assigning material IDs at nodes..." << std::endl;
_verts_ID = new int[(_n_elements_x+1)*(_n_elements_z+1)];
const double x0 = _min_coord.x(); // limits in x-direction
const double x1 = _max_coord.x();
const double z0 = _min_coord.z(); // limits in z-direction
const double z1 = _max_coord.z();
const double hx = (x1 - x0) / _n_elements_x; // step in x-direction
const double hz = (z1 - z0) / _n_elements_z; // step in z-direction
const bool throw_exception = false;
for (int iz = 0; iz < _n_elements_z+1; ++iz)
{
const double z = (iz == _n_elements_z ? z1 : z0 + iz*hz);
int triangle_index = 0; // reset the index from the previous search
for (int ix = 0; ix < _n_elements_x+1; ++ix)
{
const double x = (ix == _n_elements_x ? x1 : x0 + ix*hx);
Point2 vertex(x, z);
require(tri_mesh.contains_point(vertex), "The triangular mesh doesn't "
"contain the point: " + d2s(vertex));
// every search along the x-line at the same z-coordinate starts with the
// previously found triangle
triangle_index = tri_mesh.find_element(vertex,
triangle_index,
throw_exception);
if (triangle_index < 0) // if it wasn't found
{
std::cout << " full search for point " << vertex << std::endl;
triangle_index = tri_mesh.full_search(vertex);
}
const int mat_ID = tri_mesh.element(triangle_index).material_id();
_verts_ID[iz*(_n_elements_x+1)+ix] = mat_ID;
}
}
std::cout << "Assigning material IDs at nodes is done. Time = "
<< get_wall_time() - t0 << std::endl;
}
void RectangularMesh::
assign_material_id_in_cells(const TriangularMesh &tri_mesh)
{
double t0 = get_wall_time();
std::cout << "Assigning material IDs in cells..." << std::endl;
_cells_ID = new int[_n_elements_x*_n_elements_z];
const double x0 = _min_coord.x(); // limits in x-direction
const double x1 = _max_coord.x();
const double z0 = _min_coord.z(); // limits in z-direction
const double z1 = _max_coord.z();
const double hx = (x1 - x0) / _n_elements_x; // step in x-direction
const double hz = (z1 - z0) / _n_elements_z; // step in z-direction
const bool throw_exception = false;
for (int iz = 0; iz < _n_elements_z; ++iz)
{
const double zcen = z0 + (iz+0.5)*hz; // z-coord of a cell center
int triangle_index = 0; // reset the index from the previous search
for (int ix = 0; ix < _n_elements_x; ++ix)
{
const double xcen = x0 + (ix+0.5)*hx; // x-coord of a cell center
Point2 cell_center(xcen, zcen);
require(tri_mesh.contains_point(cell_center), "The triangular mesh "
"doesn't contain the point: " + d2s(cell_center));
// every search along the x-line at the same z-coordinate starts with the
// previously found triangle
triangle_index = tri_mesh.find_element(cell_center,
triangle_index,
throw_exception);
if (triangle_index < 0) // if it wasn't found
{
std::cout << " full search for point " << cell_center << std::endl;
triangle_index = tri_mesh.full_search(cell_center);
}
const int mat_ID = tri_mesh.element(triangle_index).material_id();
_cells_ID[iz*_n_elements_x + ix] = mat_ID;
}
}
std::cout << "Assigning material IDs in cells is done. Time = "
<< get_wall_time() - t0 << std::endl;
}
char* Simulation::text_activeBodyRotation() {
string outputString;
if (ActiveBody_Type == SPHERE) {
outputString = "Quaternion: (" +
d2s(Sphere_Bodies[ActiveBody_Index].quat()[0]) + ", " +
d2s(Sphere_Bodies[ActiveBody_Index].quat()[1]) + ", " +
d2s(Sphere_Bodies[ActiveBody_Index].quat()[2]) + ", " +
d2s(Sphere_Bodies[ActiveBody_Index].quat()[3]) + ")";
}
else if (ActiveBody_Type == TRIMESH) {
outputString = "Quaternion: (" +
d2s(Trimesh_Bodies[ActiveBody_Index].quat()[0]) + ", " +
d2s(Trimesh_Bodies[ActiveBody_Index].quat()[1]) + ", " +
d2s(Trimesh_Bodies[ActiveBody_Index].quat()[2]) + ", " +
d2s(Trimesh_Bodies[ActiveBody_Index].quat()[3]) + ")";
}
return (char*)outputString.c_str();
}
//------------------------------------------------------------------------------
//
// Time measurement (wall time)
//
//------------------------------------------------------------------------------
double get_wall_time()
{
#if defined(__linux__) || defined(__APPLE__)
struct timeval time;
const int ierr = gettimeofday(&time, NULL);
require(ierr == 0, "gettimeofday returned an error code " + d2s(ierr));
return (1.0*time.tv_sec + 1.0e-6*time.tv_usec);
#elif(_WIN32)
require(false, "Not implemented for Windows");
return 0.;
#else
require(false, "Not implemented for this unknown OS");
return 0.;
#endif
}
//------------------------------------------------------------------------------
//
// expect and require
//
//------------------------------------------------------------------------------
void requirement_fails(const char *file,
unsigned int line,
std::string message)
{
std::string exc = "Exception:\nfile = " + std::string(file) +
"\nline = " + d2s(line) +
"\nmessage = " + message + "\n";
#if defined(__linux__)
const int backtraceSize = 20;
void *array[backtraceSize];
int size = backtrace(array, backtraceSize);
char **strings = backtrace_symbols(array, size);
exc += "backtrace:\nsize = " + d2s<int>(size) + "\n";
for (int i = 0; i < size; ++i)
exc += std::string(strings[i]) + "\n";
free(strings);
#endif
throw std::runtime_error(exc);
}
/* ======================================================================== */
int gen_twiddle16(short *w, int n, double scale)
{
int i, j, k;
for (j = 1, k = 0; j < n >> 2; j = j << 2)
{
for (i = 0; i < n >> 2; i += j << 1)
{
w[k + 11] = d2s(scale * cos(6.0 * PI * (i + j) / n));
w[k + 10] = d2s(scale * sin(6.0 * PI * (i + j) / n));
w[k + 9] = d2s(scale * cos(6.0 * PI * (i ) / n));
w[k + 8] = d2s(scale * sin(6.0 * PI * (i ) / n));
w[k + 7] = d2s(scale * cos(4.0 * PI * (i + j) / n));
w[k + 6] = d2s(scale * sin(4.0 * PI * (i + j) / n));
w[k + 5] = d2s(scale * cos(4.0 * PI * (i ) / n));
w[k + 4] = d2s(scale * sin(4.0 * PI * (i ) / n));
w[k + 3] = d2s(scale * cos(2.0 * PI * (i + j) / n));
w[k + 2] = d2s(scale * sin(2.0 * PI * (i + j) / n));
w[k + 1] = d2s(scale * cos(2.0 * PI * (i ) / n));
w[k + 0] = d2s(scale * sin(2.0 * PI * (i ) / n));
k += 12;
}
}
return k;
}
int
malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
{
int ret;
size_t i;
const char *f;
#define APPEND_C(c) do { \
if (i < size) \
str[i] = (c); \
i++; \
} while (0)
#define APPEND_S(s, slen) do { \
if (i < size) { \
size_t cpylen = (slen <= size - i) ? slen : size - i; \
memcpy(&str[i], s, cpylen); \
} \
i += slen; \
} while (0)
#define APPEND_PADDED_S(s, slen, width, left_justify) do { \
/* Left padding. */ \
size_t pad_len = (width == -1) ? 0 : ((slen < (size_t)width) ? \
(size_t)width - slen : 0); \
if (left_justify == false && pad_len != 0) { \
size_t j; \
for (j = 0; j < pad_len; j++) \
APPEND_C(' '); \
} \
/* Value. */ \
APPEND_S(s, slen); \
/* Right padding. */ \
if (left_justify && pad_len != 0) { \
size_t j; \
for (j = 0; j < pad_len; j++) \
APPEND_C(' '); \
} \
} while (0)
#define GET_ARG_NUMERIC(val, len) do { \
switch (len) { \
case '?': \
val = va_arg(ap, int); \
break; \
case '?' | 0x80: \
val = va_arg(ap, unsigned int); \
break; \
case 'l': \
val = va_arg(ap, long); \
break; \
case 'l' | 0x80: \
val = va_arg(ap, unsigned long); \
break; \
case 'q': \
val = va_arg(ap, long long); \
break; \
case 'q' | 0x80: \
val = va_arg(ap, unsigned long long); \
break; \
case 'j': \
val = va_arg(ap, intmax_t); \
break; \
case 't': \
val = va_arg(ap, ptrdiff_t); \
break; \
case 'z': \
val = va_arg(ap, ssize_t); \
break; \
case 'z' | 0x80: \
val = va_arg(ap, size_t); \
break; \
case 'p': /* Synthetic; used for %p. */ \
val = va_arg(ap, uintptr_t); \
break; \
default: not_reached(); \
} \
} while (0)
i = 0;
f = format;
while (true) {
switch (*f) {
case '\0': goto label_out;
case '%': {
bool alt_form = false;
bool zero_pad = false;
bool left_justify = false;
bool plus_space = false;
bool plus_plus = false;
int prec = -1;
int width = -1;
unsigned char len = '?';
f++;
if (*f == '%') {
/* %% */
APPEND_C(*f);
break;
}
/* Flags. */
while (true) {
switch (*f) {
case '#':
assert(alt_form == false);
alt_form = true;
break;
case '0':
assert(zero_pad == false);
zero_pad = true;
break;
case '-':
assert(left_justify == false);
left_justify = true;
break;
case ' ':
assert(plus_space == false);
plus_space = true;
break;
case '+':
assert(plus_plus == false);
plus_plus = true;
break;
default: goto label_width;
}
f++;
}
/* Width. */
label_width:
switch (*f) {
case '*':
width = va_arg(ap, int);
f++;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
uintmax_t uwidth;
set_errno(0);
uwidth = malloc_strtoumax(f, (char **)&f, 10);
assert(uwidth != UINTMAX_MAX || get_errno() !=
ERANGE);
width = (int)uwidth;
if (*f == '.') {
f++;
goto label_precision;
} else
goto label_length;
break;
} case '.':
f++;
goto label_precision;
default: goto label_length;
}
/* Precision. */
label_precision:
switch (*f) {
case '*':
prec = va_arg(ap, int);
f++;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
uintmax_t uprec;
set_errno(0);
uprec = malloc_strtoumax(f, (char **)&f, 10);
assert(uprec != UINTMAX_MAX || get_errno() !=
ERANGE);
prec = (int)uprec;
break;
}
default: break;
}
/* Length. */
label_length:
switch (*f) {
case 'l':
f++;
if (*f == 'l') {
len = 'q';
f++;
} else
len = 'l';
break;
case 'j':
len = 'j';
f++;
break;
case 't':
len = 't';
f++;
break;
case 'z':
len = 'z';
f++;
break;
default: break;
}
/* Conversion specifier. */
switch (*f) {
char *s;
size_t slen;
case 'd': case 'i': {
intmax_t val JEMALLOC_CC_SILENCE_INIT(0);
char buf[D2S_BUFSIZE];
GET_ARG_NUMERIC(val, len);
s = d2s(val, (plus_plus ? '+' : (plus_space ?
' ' : '-')), buf, &slen);
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
} case 'o': {
uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
char buf[O2S_BUFSIZE];
GET_ARG_NUMERIC(val, len | 0x80);
s = o2s(val, alt_form, buf, &slen);
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
} case 'u': {
uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
char buf[U2S_BUFSIZE];
GET_ARG_NUMERIC(val, len | 0x80);
s = u2s(val, 10, false, buf, &slen);
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
} case 'x': case 'X': {
uintmax_t val JEMALLOC_CC_SILENCE_INIT(0);
char buf[X2S_BUFSIZE];
GET_ARG_NUMERIC(val, len | 0x80);
s = x2s(val, alt_form, *f == 'X', buf, &slen);
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
} case 'c': {
unsigned char val;
char buf[2];
assert(len == '?' || len == 'l');
assert_not_implemented(len != 'l');
val = va_arg(ap, int);
buf[0] = val;
buf[1] = '\0';
APPEND_PADDED_S(buf, 1, width, left_justify);
f++;
break;
} case 's':
assert(len == '?' || len == 'l');
assert_not_implemented(len != 'l');
s = va_arg(ap, char *);
slen = (prec == -1) ? strlen(s) : prec;
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
case 'p': {
uintmax_t val;
char buf[X2S_BUFSIZE];
GET_ARG_NUMERIC(val, 'p');
s = x2s(val, true, false, buf, &slen);
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
}
default: not_implemented();
}
break;
} default: {
APPEND_C(*f);
f++;
break;
}}
}
label_out:
if (i < size)
str[i] = '\0';
else
str[size - 1] = '\0';
ret = i;
#undef APPEND_C
#undef APPEND_S
#undef APPEND_PADDED_S
#undef GET_ARG_NUMERIC
return (ret);
}
void FitterUtils::prepare_PDFs(string trigStr, string BDTVar, double BDTcut,
string signalfile, string partrecofile, string combfile, string JpsiLeakfile,
double minBMass, double maxBMass,
string signaltree, string partrecotree, string combtree, string JpsiLeaktree)
{
//***********Get the datasets
TFile* fSignal = new TFile(signalfile.c_str());
TTree* tSignal = (TTree*)fSignal->Get(signaltree.c_str());
TFile* fPartReco = new TFile(partrecofile.c_str());
TTree* tPartReco = (TTree*)fPartReco->Get(partrecotree.c_str());
TFile* fComb = new TFile(combfile.c_str());
TTree* tComb = (TTree*)fComb->Get(combtree.c_str());
TFile* fJpsiLeak = new TFile(JpsiLeakfile.c_str());
TTree* tJpsiLeak = (TTree*)fJpsiLeak->Get(JpsiLeaktree.c_str());
//**********Define variables
RooRealVar trigVar(trigStr.c_str(), trigStr.c_str(), -10, 10);
RooRealVar BDTRooRealVar(BDTVar.c_str(), BDTVar.c_str(), -1,1);
RooRealVar B_plus_M("B_plus_M", "M_{visible}", minBMass, maxBMass, "MeV");
RooRealVar misPT("misPT", "p_{#perp}", 0, 5000, "MeV");
RooRealVar B_plus_DTFM_M_zero("B_plus_DTFM_M_zero", "M_{constr}", 0, 20000, "MeV");
RooRealVar e_plus_BremMultiplicity("e_plus_BremMultiplicity","e_plus_BremMultiplicity", -1,2);
RooRealVar e_minus_BremMultiplicity("e_minus_BremMultiplicity","e_minus_BremMultiplicity", -1,2);
RooRealVar weightPartReco("weightPartReco", "weightPartReco", 0, 10);
RooRealVar weightLeakage("weightLeakage", "weightLeakage", 0, 10);
RooRealVar dataMCWeightee("DataMCWeightee", "DataMCWeightee",0, 30);
//***********Set only variables needed
tSignal->SetBranchStatus("*", 0); tSignal->SetBranchStatus("B_plus_M", 1); tSignal->SetBranchStatus("misPT", 1); tSignal->SetBranchStatus("B_plus_DTFM_M_zero", 1); tSignal->SetBranchStatus(BDTVar.c_str(),1);
tSignal->SetBranchStatus("e_plus_BremMultiplicity", 1); tSignal->SetBranchStatus("e_minus_BremMultiplicity", 1); tSignal->SetBranchStatus(trigStr.c_str()); tSignal->SetBranchStatus("DataMCWeightee",1);
tPartReco->SetBranchStatus("*", 0); tPartReco->SetBranchStatus("B_plus_M", 1); tPartReco->SetBranchStatus("misPT", 1); tPartReco->SetBranchStatus("B_plus_DTFM_M_zero", 1);tPartReco->SetBranchStatus(BDTVar.c_str(),1);
tPartReco->SetBranchStatus("e_plus_BremMultiplicity", 1); tPartReco->SetBranchStatus("e_minus_BremMultiplicity", 1); tPartReco->SetBranchStatus(trigStr.c_str()); tPartReco->SetBranchStatus("weightPartReco",1);
tComb->SetBranchStatus("*", 0); tComb->SetBranchStatus("B_plus_M", 1); tComb->SetBranchStatus("misPT", 1); tComb->SetBranchStatus("B_plus_DTFM_M_zero", 1);tComb->SetBranchStatus(BDTVar.c_str(),1);
tComb->SetBranchStatus("e_plus_BremMultiplicity", 1); tComb->SetBranchStatus("e_minus_BremMultiplicity", 1); tComb->SetBranchStatus(trigStr.c_str());
tJpsiLeak->SetBranchStatus("*", 0); tJpsiLeak->SetBranchStatus("B_plus_M", 1); tJpsiLeak->SetBranchStatus("misPT", 1);
tJpsiLeak->SetBranchStatus("B_plus_DTFM_M_zero", 1);tJpsiLeak->SetBranchStatus(BDTVar.c_str(),1);
tJpsiLeak->SetBranchStatus("e_plus_BremMultiplicity", 1); tJpsiLeak->SetBranchStatus("e_minus_BremMultiplicity", 1); tJpsiLeak->SetBranchStatus(trigStr.c_str());
tJpsiLeak->SetBranchStatus("weightLeakage",1);
//***********Set Binning
RooBinning defaultMBins(floor((maxBMass-minBMass)/(40.)), B_plus_M.getMin(), B_plus_M.getMax() );
RooBinning defaultMisPTBins(floor(40), misPT.getMin(), misPT.getMax());
RooBinning broaderMBins(floor((maxBMass-minBMass)/(80.)), B_plus_M.getMin(), B_plus_M.getMax());
RooBinning broaderMisPTBins(floor(40), misPT.getMin(), misPT.getMax());
B_plus_M.setBinning( defaultMBins);
misPT.setBinning( defaultMisPTBins );
B_plus_M.setBinning( broaderMBins, "broaderBins");
misPT.setBinning( broaderMisPTBins, "broaderBins" );
B_plus_DTFM_M_zero.setBins(100);
RooArgSet argset(BDTRooRealVar, B_plus_DTFM_M_zero, misPT, B_plus_M, trigVar, e_plus_BremMultiplicity, e_minus_BremMultiplicity);
RooArgSet argsetPartReco(BDTRooRealVar, B_plus_DTFM_M_zero, misPT, B_plus_M, trigVar, e_plus_BremMultiplicity, e_minus_BremMultiplicity, weightPartReco);
RooArgSet argsetLeakage(BDTRooRealVar, B_plus_DTFM_M_zero, misPT, B_plus_M, trigVar, e_plus_BremMultiplicity, e_minus_BremMultiplicity, weightLeakage);
RooArgSet argsetSignal(BDTRooRealVar, B_plus_DTFM_M_zero, misPT, B_plus_M, trigVar, e_plus_BremMultiplicity, e_minus_BremMultiplicity, dataMCWeightee);
cout<<"getting the datasets:"<<endl;
RooDataSet* dataSetSignalZeroGamma;
RooDataSet* dataSetSignalOneGamma;
RooDataSet* dataSetSignalTwoGamma;
RooDataSet* dataSetPartReco;
RooDataSet* dataSetJpsiLeak;
RooDataSet* dataSetComb;
TFile* fw(NULL);
string BDTCutString( ("("+BDTVar+">"+d2s(BDTcut)+")").c_str() );
dataSetSignalZeroGamma = new RooDataSet("dataSetSignalZeroGamma", "dataSetSignalZeroGamma", argsetSignal, Import(*tSignal), Cut(( " ("+trigStr+" > 0.9) && "+BDTCutString+" && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) > -0.5) && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) < 0.5) && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()), WeightVar("DataMCWeightee") );
dataSetSignalOneGamma = new RooDataSet("dataSetSignalOneGamma", "dataSetSignalOneGamma", argsetSignal, Import(*tSignal), Cut(( " ("+trigStr+" > 0.9) && "+BDTCutString+" && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) > 0.5) && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) < 1.5) && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()), WeightVar("DataMCWeightee") );
dataSetSignalTwoGamma = new RooDataSet("dataSetSignalTwoGamma", "dataSetSignalTwoGamma", argsetSignal, Import(*tSignal), Cut(( " ("+trigStr+" > 0.9) && "+BDTCutString+" && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) > 1.5) && ((e_plus_BremMultiplicity+e_minus_BremMultiplicity) < 2.5) && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()), WeightVar("DataMCWeightee") );
dataSetPartReco = new RooDataSet("dataSetPartReco", "dataSetPartReco", argsetPartReco, Import(*tPartReco),Cut(("("+trigStr+" > 0.9) && "+BDTCutString+ " && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()), WeightVar("weightPartReco"));
dataSetJpsiLeak = new RooDataSet("dataSetJpsiLeak", "dataSetJpsiLeak", argsetLeakage, Import(*tJpsiLeak),Cut(("B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()), WeightVar("weightLeakage"));
// dataSetComb = new RooDataSet("dataSetComb", "dataSetComb", tComb, argset, ("("+trigStr+" > 0.9) && (UBDT3R > "+d2s(BDTcut-0.03)+") && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str());
dataSetComb = new RooDataSet("dataSetComb", "dataSetComb", tComb, argset, ("("+trigStr+" > 0.9) && "+BDTCutString+" && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str());
cout<<"Number of zero: "<< dataSetSignalZeroGamma->sumEntries()<<endl;
cout<<"Number of one: "<< dataSetSignalOneGamma->sumEntries()<<endl;
cout<<"Number of two: "<< dataSetSignalTwoGamma->sumEntries()<<endl;
cout<<"Number of PartReco: "<< dataSetPartReco->sumEntries()<<endl;
cout<<"Number of Jpsi leaking:"<< dataSetJpsiLeak->sumEntries()<<endl;
cout<<"Number of combinatorial events:"<< dataSetComb->sumEntries()<<endl;
cout<<"binning the datasets:"<<endl;
RooArgSet argset2(B_plus_M);
if (fit2D) argset2.add(misPT);
RooDataHist dataHistSignalZeroGamma("dataHistSignalZeroGamma", "dataHistSignalZeroGamma", argset2, *dataSetSignalZeroGamma);
RooDataHist dataHistSignalOneGamma("dataHistSignalOneGamma", "dataHistSignalOneGamma", argset2, *dataSetSignalOneGamma);
RooDataHist dataHistSignalTwoGamma("dataHistSignalTwoGamma", "dataHistSignalTwoGamma", argset2, *dataSetSignalTwoGamma);
RooDataHist dataHistComb("dataHistComb", "dataHistComb", argset2, *dataSetComb);
RooDataHist dataHistPartReco("dataHistPartReco", "dataHistPartReco", argset2, *dataSetPartReco);
RooDataHist dataHistJpsiLeak("dataHistJpsiLeak", "dataHistJpsiLeak", argset2, "broaderBins");
dataHistJpsiLeak.add(*dataSetJpsiLeak);
//*************** Compute Error on J/psi leak
double ErrorJpsi(0);
if(dataSetJpsiLeak->sumEntries(("("+trigStr+" > 0.9) && "+BDTCutString+" && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()) > 0) ErrorJpsi = 1./sqrt(dataSetJpsiLeak->sumEntries(("("+trigStr+" > 0.9) && "+BDTCutString+" && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str()));
RooRealVar fractionalErrorJpsiLeak("fractionalErrorJpsiLeak", "fractionalErrorJpsiLeak", ErrorJpsi);
cout<<"JPSI LEAK: "<<dataSetJpsiLeak->sumEntries(("("+trigStr+" > 0.9) && "+BDTCutString+" && B_plus_M > "+d2s(minBMass)+" && B_plus_M < "+d2s(maxBMass)).c_str());
cout<<"JPSI LEAK fractional Error: "<<ErrorJpsi<<endl;
//***************Create 2D histogram estimates from data
cout<<"Preparing the 3 2D histPdf: 1";
// RooArgSet argset2(B_plus_M);
RooHistPdf histPdfSignalZeroGamma("histPdfSignalZeroGamma", "histPdfSignalZeroGamma", argset2, dataHistSignalZeroGamma,2); cout<<" 2";
RooHistPdf histPdfSignalOneGamma("histPdfSignalOneGamma", "histPdfSignalOneGamma", argset2, dataHistSignalOneGamma,2); cout<<" 3";
RooHistPdf histPdfSignalTwoGamma("histPdfSignalTwoGamma", "histPdfSignalTwoGamma", argset2, dataHistSignalTwoGamma,2); cout<<" 4";
RooHistPdf histPdfPartReco("histPdfPartReco", "histPdfPartReco", argset2, dataHistPartReco,2); cout<<" 5";
RooHistPdf histPdfJpsiLeak("histPdfJpsiLeak", "histPdfJpsiLeak", argset2, dataHistJpsiLeak,2); cout<<" 6";
//***************Create combinatorial from fit to data
RooRealVar expoConst("expoConst", "expoConst", -1e-3, -1, 1);
RooRealVar T("T", "T", 97, 0, 200);
RooRealVar n("n", "n", 3.5, 1., 5.5);
RooAbsPdf *combPDF;
if (fit2D)
{
combPDF = new RooPTMVis("PTMVis", "PTMVis", misPT, B_plus_M, T, n, expoConst);
}
else
{
combPDF = new RooExponential("histPdfComb", "histPdfComb", B_plus_M, expoConst);
}
combPDF->fitTo(*dataSetComb); //
if (fit2D)
{
T.setConstant(true);
n.setConstant(true);
std::cout<<"T generated is: "<<T.getVal()<<std::endl;
}
RooRealVar trueExp("trueExp","trueExp", expoConst.getVal(), -1000, 1000);
trueExp.setError(expoConst.getError());
RooRealVar trueT("trueT","trueT", T.getVal(), -1000, 1000);
trueT.setError(T.getError());
RooRealVar trueN("trueN","trueN", n.getVal(), -1000, 1000);
trueN.setError(n.getError());
//***************Save everything on a workspace
RooWorkspace workspace("workspace", "workspace");
workspace.import(B_plus_DTFM_M_zero);
workspace.import(B_plus_M);
workspace.import(misPT);
workspace.import(expoConst);
workspace.import(trueExp);
workspace.import(T);
workspace.import(n);
workspace.import(*dataSetSignalZeroGamma);
workspace.import(*dataSetSignalOneGamma);
workspace.import(*dataSetSignalTwoGamma);
workspace.import(*dataSetPartReco);
workspace.import(*dataSetComb);
workspace.import(*dataSetJpsiLeak);
workspace.import(histPdfSignalZeroGamma);
workspace.import(histPdfSignalOneGamma);
workspace.import(histPdfSignalTwoGamma);
workspace.import(histPdfPartReco);
workspace.import(histPdfJpsiLeak);
workspace.import(fractionalErrorJpsiLeak);
workspace.import(trueT);
workspace.import(trueN);
workspace.writeToFile(workspacename.c_str());
delete fComb;
delete fSignal;
delete fPartReco;
if(fw!=0 && fw != NULL) delete fw;
delete combPDF;
delete dataSetSignalZeroGamma;
delete dataSetSignalOneGamma;
delete dataSetSignalTwoGamma;
delete dataSetPartReco;
delete dataSetJpsiLeak;
delete dataSetComb;
}
int gen_twiddle_fft16x16(short *w, int n)
{
int i, j, k;
double M = 32767.5;
const double PI = 3.141592654;
for (j = 1, k = 0; j < n >> 2; j = j << 2) {
for (i = 0; i < n >> 2; i += j << 1) {
w[k + 11] = d2s(M * cos(6.0 * PI * (i + j) / n));
w[k + 10] = d2s(M * sin(6.0 * PI * (i + j) / n));
w[k + 9] = d2s(M * cos(6.0 * PI * (i ) / n));
w[k + 8] = d2s(M * sin(6.0 * PI * (i ) / n));
w[k + 7] = -d2s(M * cos(4.0 * PI * (i + j) / n));
w[k + 6] = -d2s(M * sin(4.0 * PI * (i + j) / n));
w[k + 5] = -d2s(M * cos(4.0 * PI * (i ) / n));
w[k + 4] = -d2s(M * sin(4.0 * PI * (i ) / n));
w[k + 3] = d2s(M * cos(2.0 * PI * (i + j) / n));
w[k + 2] = d2s(M * sin(2.0 * PI * (i + j) / n));
w[k + 1] = d2s(M * cos(2.0 * PI * (i ) / n));
w[k + 0] = d2s(M * sin(2.0 * PI * (i ) / n));
k += 12;
}
}
return k;
}
bool EmdL1::GreedySolution2()
{
//- Prepare auxiliary array, D=H1-H2
int c,r;
EMDTYPEArray2D D(m_n1);
for(r=0;r<m_n1;++r) {
D[r].resize(m_n2);
for(c=0;c<m_n2;++c) D[r][c] = m_Nodes[r][c].d;
}
// compute integrated values along each dimension
std::vector<EMDTYPE> d2s(m_n2);
d2s[0] = 0;
for(c=0; c<m_n2-1; ++c) {
d2s[c+1] = d2s[c];
for(r=0; r<m_n1; ++r) d2s[c+1]-= D[r][c];
}
std::vector<EMDTYPE> d1s(m_n1);
d1s[0] = 0;
for(r=0; r<m_n1-1; ++r) {
d1s[r+1] = d1s[r];
for(c=0; c<m_n2; ++c) d1s[r+1]-= D[r][c];
}
//- Greedy algorithm for initial solution
PEmdEdge pBV;
EMDTYPE dFlow;
bool bUpward = false;
m_nNBV = 0; // number of NON-BV edges
for(c=0; c<m_n2-1; ++c)
for(r=0; r<m_n1; ++r)
{
dFlow = D[r][c];
bUpward = (r<m_n1-1) && (abs(dFlow+d2s[c+1]) > abs(dFlow+d1s[r+1])); // Move upward or right
// modify basic variables, record BV and related values
if(bUpward) {
// move to up
pBV = &(m_EdgesUp[r][c]);
m_NBVEdges[m_nNBV++] = &(m_EdgesRight[r][c]);
D[r+1][c] += dFlow; // auxilary matrix maintanence
d1s[r+1] += dFlow; // auxilary matrix maintanence
}
else{
// move to right, no other choice
pBV = &(m_EdgesRight[r][c]);
if(r<m_n1-1)
m_NBVEdges[m_nNBV++] = &(m_EdgesUp[r][c]);
D[r][c+1] += dFlow; // auxilary matrix maintanence
d2s[c+1] += dFlow; // auxilary matrix maintanence
}
pBV->pParent->pChild= pBV;
pBV->flow = abs(dFlow);
pBV->iDir = dFlow>0; // 1:outward, 0:inward
}
//- rightmost column, no choice but move upward
c = m_n2-1;
for(r=0; r<m_n1-1; ++r) {
dFlow = D[r][c];
pBV = &(m_EdgesUp[r][c]);
D[r+1][c] += dFlow; // auxilary matrix maintanence
pBV->pParent->pChild= pBV;
pBV->flow = abs(dFlow);
pBV->iDir = dFlow>0; // 1:outward, 0:inward
}
return true;
}
bool EmdL1::GreedySolution3()
{
//- Prepare auxiliary array, D=H1-H2
int i1,i2,i3;
std::vector<EMDTYPEArray2D> D(m_n1);
for(i1=0; i1<m_n1; ++i1) {
D[i1].resize(m_n2);
for(i2=0; i2<m_n2; ++i2) {
D[i1][i2].resize(m_n3);
for(i3=0; i3<m_n3; ++i3)
D[i1][i2][i3] = m_3dNodes[i1][i2][i3].d;
}
}
// compute integrated values along each dimension
std::vector<EMDTYPE> d1s(m_n1);
d1s[0] = 0;
for(i1=0; i1<m_n1-1; ++i1) {
d1s[i1+1] = d1s[i1];
for(i2=0; i2<m_n2; ++i2)
for(i3=0; i3<m_n3; ++i3)
d1s[i1+1] -= D[i1][i2][i3];
}
std::vector<EMDTYPE> d2s(m_n2);
d2s[0] = 0;
for(i2=0; i2<m_n2-1; ++i2) {
d2s[i2+1] = d2s[i2];
for(i1=0; i1<m_n1; ++i1)
for(i3=0; i3<m_n3; ++i3)
d2s[i2+1] -= D[i1][i2][i3];
}
std::vector<EMDTYPE> d3s(m_n3);
d3s[0] = 0;
for(i3=0; i3<m_n3-1; ++i3) {
d3s[i3+1] = d3s[i3];
for(i1=0; i1<m_n1; ++i1)
for(i2=0; i2<m_n2; ++i2)
d3s[i3+1] -= D[i1][i2][i3];
}
//- Greedy algorithm for initial solution
PEmdEdge pBV;
EMDTYPE dFlow, f1,f2,f3;
m_nNBV = 0; // number of NON-BV edges
for(i3=0; i3<m_n3; ++i3)
for(i2=0; i2<m_n2; ++i2)
for(i1=0; i1<m_n1; ++i1)
{
if(i3==m_n3-1 && i2==m_n2-1 && i1==m_n1-1) break;
//- determine which direction to move, either right or upward
dFlow = D[i1][i2][i3];
f1 = i1<m_n1-1 ? abs(dFlow+d1s[i1+1]) : EMDINF;
f2 = i2<m_n2-1 ? abs(dFlow+d2s[i2+1]) : EMDINF;
f3 = i3<m_n3-1 ? abs(dFlow+d3s[i3+1]) : EMDINF;
if(f1<f2 && f1<f3) {
pBV = &(m_3dEdgesUp[i1][i2][i3]); // up
if(i2<m_n2-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesRight[i1][i2][i3]); // right
if(i3<m_n3-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesDeep[i1][i2][i3]); // deep
D[i1+1][i2][i3] += dFlow; // maintain auxilary matrix
d1s[i1+1] += dFlow;
}
else if(f2<f3) {
pBV = &(m_3dEdgesRight[i1][i2][i3]); // right
if(i1<m_n1-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesUp[i1][i2][i3]); // up
if(i3<m_n3-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesDeep[i1][i2][i3]); // deep
D[i1][i2+1][i3] += dFlow; // maintain auxilary matrix
d2s[i2+1] += dFlow;
}
else {
pBV = &(m_3dEdgesDeep[i1][i2][i3]); // deep
if(i2<m_n2-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesRight[i1][i2][i3]); // right
if(i1<m_n1-1) m_NBVEdges[m_nNBV++] = &(m_3dEdgesUp[i1][i2][i3]); // up
D[i1][i2][i3+1] += dFlow; // maintain auxilary matrix
d3s[i3+1] += dFlow;
}
pBV->flow = abs(dFlow);
pBV->iDir = dFlow>0; // 1:outward, 0:inward
pBV->pParent->pChild= pBV;
}
return true;
}
