void YumMifJob::process(){try{
QImage image(source);
TASSUME(!image.isNull(),"Could not load picture (Is it corrupted?)");
Yum y(isofile,number);
TASSUME(y.issue.isEmpty(),y.issue);
MifFile mif(y.torw());
TASSUME(mif.issue.isEmpty(),QString("File %1 inside yum archive - %2").arg(number).arg(mif.issue));
MifConversionResult res=mif.read(image);
TASSUME(mif.issue.isEmpty(),QString("File %1 inside yum archive - %2").arg(number).arg(mif.issue));
QByteArray bytes=mif.spit();
y.spit(bytes.data(),bytes.count());
TASSUME(y.issue.isEmpty(),y.issue);
// rwfile rw("res.txt");
// rw.write(bytes.data(),bytes.count());
state=JOB_STATE_OK;
// if(res.remapped!=0)
// output+=QString("%1 overlapping rectangles were remapped").arg(res.remapped),
// state=JOB_STATE_WARNINGS;
if(res.skipped!=0)
output+=QString("%1 rectangles were not present in picture and were skipped").arg(res.skipped),
state=JOB_STATE_WARNINGS;
} catch(QString ss){
state=JOB_STATE_FAILED;
}}
int main(int argc, char* argv[])
{
if (argc != 3) {
std::cout << "Usage: " << argv[0] << " <NUMBER_OF_THREADS> <DATA_SIZE>" << std::endl;
exit(1);
}
const int NUMBER_OF_THREADS = atoi(argv[1]);
const int DATA_SIZE = atoi(argv[2]);
const int CHUNK_SIZE = DATA_SIZE / NUMBER_OF_THREADS;
srand(time(NULL));
tbb::task_scheduler_init init(NUMBER_OF_THREADS);
std::vector<float> data(DATA_SIZE);
for (int i = 0; i < DATA_SIZE; i++)
data[i] = rand() % RANDOM_MAX + RANDOM_MIN;
itbbReduce mif(data);
timespec startTime;
clock_gettime(CLOCK_MONOTONIC, &startTime);
tbb::parallel_reduce(tbb::blocked_range<size_t>(0, data.size(), CHUNK_SIZE), mif);
float min = mif.m_min;
timespec endTime;
clock_gettime(CLOCK_MONOTONIC, &endTime);
timespec timeDiff = diff(startTime, endTime);
std::cout << timeDiff.tv_sec << "." << timeDiff.tv_nsec << std::endl;
return 0;
}
void
MeshfreeSolutionTransfer::transfer(const Variable & from_var,
const Variable & to_var)
{
libmesh_experimental();
System * from_sys = from_var.system();
System * to_sys = to_var.system();
EquationSystems & from_es = from_sys->get_equation_systems();
MeshBase & from_mesh = from_es.get_mesh();
InverseDistanceInterpolation<LIBMESH_DIM> idi
(from_mesh.comm(), 4, 2);
std::vector<Point> & src_pts (idi.get_source_points());
std::vector<Number> & src_vals (idi.get_source_vals());
std::vector<std::string> field_vars;
field_vars.push_back(from_var.name());
idi.set_field_variables(field_vars);
// We now will loop over every node in the source mesh
// and add it to a source point list, along with the solution
{
MeshBase::const_node_iterator nd = from_mesh.local_nodes_begin();
MeshBase::const_node_iterator end = from_mesh.local_nodes_end();
for (; nd!=end; ++nd)
{
const Node * node = *nd;
src_pts.push_back(*node);
src_vals.push_back((*from_sys->solution)(node->dof_number(from_sys->number(),from_var.number(),0)));
}
}
// We have only set local values - prepare for use by gathering remote gata
idi.prepare_for_use();
// Create a MeshlessInterpolationFunction that uses our
// InverseDistanceInterpolation object. Since each
// MeshlessInterpolationFunction shares the same
// InverseDistanceInterpolation object in a threaded environment we
// must also provide a locking mechanism.
Threads::spin_mutex mutex;
MeshlessInterpolationFunction mif(idi, mutex);
// project the solution
to_sys->project_solution(&mif);
}
XSqlQuery MetaSQLQuery::toQuery(const ParameterList & params, QSqlDatabase pDb, bool pExec) {
XSqlQuery qry(pDb);
if(isValid()) {
MetaSQLInfoQt mif(params);
if(qry.prepare(QString::fromStdString(_data->populate(&mif)))) {
for ( std::map<std::string, QVariant>::iterator it=mif._pList.begin() ; it != mif._pList.end(); it++ ) {
qry.bindValue(QString::fromStdString((*it).first) ,(*it).second);
}
if(pExec) {
qry.exec();
}
}
}
return qry;
}
