/**
* @ingroup VanDerPol
*/
double run_vdp_sdc(const size_t nsteps, const double dt, const size_t nnodes,
const size_t niters, const double nu, const double x0,
const double y0, const quadrature::QuadratureType nodetype)
{
SDC<> sdc;
auto quad = quadrature::quadrature_factory(nnodes, nodetype);
// van der Pol oscillator (as first order system) has two components
auto factory = make_shared<encap::VectorFactory<double>>(2);
// input is parameter nu and initial values for position and velocity
auto sweeper = make_shared<VdpSweeper<>>(nu, x0, y0);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sdc.add_level(sweeper);
// Final time Tend = dt*nsteps
sdc.set_duration(0.0, dt*nsteps, dt, niters);
sdc.setup();
auto q0 = sweeper->get_start_state();
sweeper->exact(q0, 0.0);
sdc.run();
return sweeper->get_errors();
}
/**
* Advection/diffusion example using an encapsulated IMEX sweeper.
*
* This example uses a vanilla SDC sweeper.
*
* @ingroup AdvectionDiffusion
*/
error_map run_vanilla_sdc(double abs_residual_tol, double rel_residual_tol=0.0)
{
SDC<> sdc;
auto const nnodes = config::get_value<size_t>("num_nodes", 3);
auto const ndofs = config::get_value<size_t>("spatial_dofs", 64);
auto const quad_type = \
config::get_value<quadrature::QuadratureType>("nodes_type", quadrature::QuadratureType::GaussLegendre);
auto quad = quadrature::quadrature_factory(nnodes, quad_type);
auto factory = make_shared<encap::VectorFactory<double>>(ndofs);
auto sweeper = make_shared<AdvectionDiffusionSweeper<>>(ndofs);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sweeper->set_residual_tolerances(abs_residual_tol, rel_residual_tol);
sdc.add_level(sweeper);
sdc.set_duration(0.0, 4*0.01, 0.01, 4);
sdc.set_options();
sdc.setup();
auto q0 = sweeper->get_start_state();
sweeper->exact(q0, 0.0);
sdc.run();
fftw_cleanup();
return sweeper->get_errors();
}
int
main(int argc, char *argv[])
{
const gchar* connection_string = "HOST=localhost;USER=murrayc;PASSWORD=yourpasswordhere;DATABASE=template1";
GdaClient *client = 0;
GdaConnection *con = 0;
gda_init ("glom-gda-test", NULL, argc, argv);
/* 3. Create a gda client */
client = gda_client_new ();
/* 4. Open the connection */
con = gda_client_open_connection_from_string (client, "PostgreSQL", connection_string, 0);
if (!GDA_IS_CONNECTION (con)) {
g_print ("** ERROR: could not open connection.\n");
/* This cannot work because it needs a working connection: get_errors (con); */
return 0;
}
gboolean created = gda_connection_create_database(con, "glomtest");
if(!created) {
g_print("** Error: gda_connection_create_database failed.\n");
get_errors(con);
}
gda_connection_close (con);
g_object_unref (G_OBJECT (client));
g_print ("** Connection successfully opened, database created, and connection closed.\n");
return 0;
}
void CheckNSCP::check_nscp(const Plugin::QueryRequestMessage::Request &request, Plugin::QueryResponseMessage::Response *response) {
po::options_description desc = nscapi::program_options::create_desc(request);
po::variables_map vm;
if (!nscapi::program_options::process_arguments_from_request(vm, desc, request, *response))
return;
response->set_result(Plugin::Common_ResultCode_OK);
std::string last, message;
int crash_count = get_crashes(crashFolder, last);
str::format::append_list(message, str::xtos(crash_count) + " crash(es)", std::string(", "));
if (crash_count > 0) {
response->set_result(Plugin::Common_ResultCode_CRITICAL);
str::format::append_list(message, std::string("last crash: " + last), std::string(", "));
}
int err_count = get_errors(last);
str::format::append_list(message, str::xtos(err_count) + " error(s)", std::string(", "));
if (err_count > 0) {
response->set_result(Plugin::Common_ResultCode_CRITICAL);
str::format::append_list(message, std::string("last error: " + last), std::string(", "));
}
boost::posix_time::ptime end = boost::posix_time::microsec_clock::local_time();;
boost::posix_time::time_duration td = end - start_;
std::stringstream uptime;
uptime << "uptime " << td;
str::format::append_list(message, uptime.str(), std::string(", "));
response->add_lines()->set_message(message);
}
CL::Exception::Exception(cl_int err_code, const string& file, int line_no):
_file(file), _line_no(line_no)
{
get_errors();
switch(err_code) {
case CL_BUILD_PROGRAM_FAILURE: _msg = "Program build failure"; break;
case CL_COMPILER_NOT_AVAILABLE: _msg = "Compiler not available"; break;
case CL_INVALID_ARG_INDEX: _msg = "Invalid kernel argument index"; break;
case CL_INVALID_ARG_SIZE: _msg = "Invalid kernel argument size"; break;
case CL_INVALID_ARG_VALUE: _msg = "Invalid kernel argument value"; break;
case CL_INVALID_BINARY: _msg = "Invalid binary"; break;
case CL_INVALID_BUFFER_SIZE: _msg = "Invalid buffer size"; break;
case CL_INVALID_BUILD_OPTIONS: _msg = "Invalid build options"; break;
case CL_INVALID_COMMAND_QUEUE: _msg = "Invalid command queue"; break;
case CL_INVALID_CONTEXT: _msg = "Invalid context"; break;
case CL_INVALID_DEVICE: _msg = "Invalid device"; break;
case CL_INVALID_EVENT_WAIT_LIST: _msg = "Invalid event wait list"; break;
case CL_INVALID_EVENT: _msg = "Invalid event";
case CL_INVALID_GLOBAL_OFFSET: _msg = "Invalid global offset"; break;
case CL_INVALID_GLOBAL_WORK_SIZE: _msg = "Invalid global work size"; break;
case CL_INVALID_GL_OBJECT: _msg = "Invalid OpenGL object"; break;
case CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR: _msg = "Invalid OpenGL sharegroup reference"; break;
case CL_INVALID_IMAGE_SIZE: _msg = "Invalid image size"; break;
case CL_INVALID_KERNEL: _msg = "Invalid kernel"; break;
case CL_INVALID_KERNEL_ARGS: _msg = "(Some) kernel args not specified"; break;
case CL_INVALID_KERNEL_DEFINITION: _msg = "Invalid kernel definition"; break;
case CL_INVALID_KERNEL_NAME: _msg = "Kernel name not found in program"; break;
case CL_INVALID_MEM_OBJECT: _msg = "Invalid mem object"; break;
case CL_INVALID_MIP_LEVEL: _msg = "Invalid miplevel"; break;
case CL_INVALID_OPERATION: _msg = "Invalid operation"; break;
case CL_INVALID_PROGRAM: _msg = "Invalid program"; break;
case CL_INVALID_PROGRAM_EXECUTABLE: _msg = "Program not built successfully"; break;
case CL_INVALID_PROPERTY: _msg = "Invalid property"; break;
case CL_INVALID_SAMPLER: _msg = "Invalid sampler object"; break;
case CL_INVALID_VALUE: _msg = "Invalid value"; break;
case CL_INVALID_WORK_DIMENSION: _msg = "Invalid work dimension"; break;
case CL_INVALID_WORK_GROUP_SIZE: _msg = "Invalid work group size"; break;
case CL_INVALID_WORK_ITEM_SIZE: _msg = "Invalid work item size"; break;
case CL_MEM_OBJECT_ALLOCATION_FAILURE: _msg = "Mem-object allocation failure"; break;
case CL_MISALIGNED_SUB_BUFFER_OFFSET: _msg = "Misaligned sub-buffer offset"; break;
case CL_OUT_OF_HOST_MEMORY: _msg = "Out of host memory"; break;
case CL_OUT_OF_RESOURCES: _msg = "Out of resources"; break;
case CL_PROFILING_INFO_NOT_AVAILABLE: _msg = "Profiling info not available"; break;
case -1001: _msg = "Vendor ICD not correctly installed(?)"; break;
default: _msg = "Unknown error: " + to_string(err_code);
}
#ifdef DEBUG_OPENCL
raise(SIGTRAP);
#endif
}
uint8_t I2C::read_byte(i2caddr_t addr, uint8_t regaddr){
uint8_t ret;
msg_t msg;
i2cflags_t flags;
msg = transmit(addr, ®addr, 1, &ret, 1, MS2ST(4));
if(msg == RDY_OK){
return ret;
} else {
flags = get_errors();
return 0;
}
}
error_map<scalar> run_boris_sdc()
{
pfasst::SDC<> sdc;
const size_t nsteps = pfasst::config::get_value<size_t>("num_steps", 10);
const double dt = pfasst::config::get_value<double>("delta_step", 0.015625);
const size_t nnodes = pfasst::config::get_value<size_t>("num_nodes", 5);
// const size_t nparticles = 1;
const size_t niters = pfasst::config::get_value<size_t>("num_iter", 7);
const double mass = 1.0;
const double charge = 1.0;
const double epsilon = pfasst::config::get_value<scalar>("epsilon", -1.0);
auto quad = pfasst::quadrature::quadrature_factory<double>(nnodes, pfasst::quadrature::QuadratureType::GaussLobatto);
auto factory = make_shared<Particle3DFactory<double, double>>(mass, charge);
typedef SimplePhysicsEnergyOperator<double, double, Particle3DEncapsulation,
IdealQuadrupolePotential, ConstantMagneticField> energy_operator_type;
energy_operator_type::e_field_type e_field(epsilon);
energy_operator_type::b_field_type b_field;
energy_operator_type e_operator(e_field, b_field, epsilon);
auto sweeper = make_shared<pfasst::examples::boris::BorisSweeper<double, double, energy_operator_type>>(e_operator, epsilon);
sweeper->set_energy_operator(e_operator);
sweeper->set_quadrature(quad);
sweeper->set_factory(factory);
sdc.add_level(sweeper);
sdc.set_duration(0.0, nsteps*dt, dt, niters);
sdc.setup();
auto p0 = dynamic_pointer_cast<Particle3DEncapsulation<double, double>>(sweeper->get_state(0));
p0->pos().x = 10;
p0->vel().u = 100;
p0->vel().w = 100;
sweeper->set_initial_energy();
cout << "Initial Particle: " << *(dynamic_pointer_cast<Particle3DEncapsulation<double, double>>(sweeper->get_state(0))) << endl;
sdc.run();
return sweeper->get_errors();
}
bool BoxClass::Compile(CompileCallback * callback, const char * logic) {
set_callback callback_holder(this,callback);
if (!setjmp(weiter_gehts_nach_compilerfehler)) {
loesche_syntax_speicher(box);
// init_yylex ();
mutabor_programm_einlesen (box, logic);
if (callback) {
callback->SetStatus(logik_list_laenge(box->file->list_of_logiken),
ton_list_laenge(box->file->list_of_toene),
umstimmungs_list_laenge(box->file->list_of_umstimmungen),
tonsystem_list_laenge(box->file->list_of_tonsysteme),
intervall_list_laenge(box->file->list_of_intervalle),
box->scanner->anzahl_eingelesene_zeichen);
// show_line_number(-1);
callback->SetStatus(_("Generating tables"));
callback->Refresh();
}
expand_decition_tree(box);
if (callback) {
callback->SetStatus(_("Translation successful"));
callback->SetMessage(_("No error occured."));
callback->Refresh();
}
return true;
} else {
//show_line_number(-1);
if (callback) {
callback->SetStatus(_("Translation interrupted."));
callback->SetMessage(get_errors());
callback->Refresh();
}
return false;
}
}
