/*
* the main method
* receives a Flow message and prints out its associated information
* If the message belongs to another class, an exception is thrown.
*/
virtual void _receive_msg(std::shared_ptr<const Msg>&& m, int /* index */)
{
if ( m->type() == MSG_ID(Flow) )
{
auto flow = static_cast<const Flow *>(m.get());
std::stringstream ss;
const FlowKey& fk = flow->key();
int duration = flow->end_time() - flow->start_time();
ss<<"packets="<<flow->packets() << ",";
ss<<"bytes="<<flow->bytes() << ",";
ss<<"start="<<flow->start_time() << ",";
ss<<"end="<<flow->end_time() << ",";
ss<<"duration.us="<<duration<< ",";
ss<<"source.ip4="<<ip_to_string(fk.src_ip4)<< ",";
ss<<"source.port="<<fk.src_port<< ",";
ss<<"destination.ip4="<<ip_to_string(fk.dst_ip4)<< ",";
ss<<"destination.port="<<fk.dst_port;
/*
ss<<"Flow of "<< flow->packets() << " packets and "<<flow->bytes()<<" bytes begin at "<<flow->start_time()<<" end at "<<flow->end_time()<< "duration (ms.) "<<duration <<std::endl;
ss<<"SRC IP "<<ip_to_string(fk.src_ip4)<<" SRC port "<<fk.src_port<<std::endl;
ss<<"DST IP "<<ip_to_string(fk.dst_ip4)<<" DST port "<<fk.dst_port<<std::endl;
//ss<<"protocol "<<fk.proto<<std::endl;
*/
blocklog(ss.str(),log_info);
}
else
{
throw std::runtime_error("Flowprinter: wrong message type");
}
}
int main() {
int i;
double libc, fire;
struct firedns_state state, *s = &state;
firedns_init(s);
firedns_add_servers_from_resolv_conf(s);
printf("Testing %d firedns_resolveip4list(\"%s\"):\n",TESTS,TEST_HOST);
start_time();
for (i = 0; i < TESTS; i++)
firedns_resolveip4list(s, TEST_HOST);
fire = end_time();
printf("Testing %d gethostbyname(\"%s\"):\n",TESTS,TEST_HOST);
start_time();
for (i = 0; i < TESTS; i++)
gethostbyname(TEST_HOST);
libc = end_time();
if (libc > fire)
printf("Speedup: %d%%\n",(int) (((libc - fire) / libc) * 100.0));
else
printf("Slowdown: %d%%\n",(int) (((fire - libc) / libc) * 100.0));
return 0;
}
void prolongate( int level ) {
int i,j;
const int prolongation_vars[1] = { VAR_POTENTIAL };
int icell;
int num_level_cells;
int *level_cells;
cart_assert( level >= min_level+1 );
start_time( WORK_TIMER );
select_level( level-1, CELL_TYPE_LOCAL | CELL_TYPE_REFINED, &num_level_cells, &level_cells );
#pragma omp parallel for default(none), private(i,icell,j), shared(num_level_cells,level_cells,cell_vars,cell_child_oct)
for ( i = 0; i < num_level_cells; i++ ) {
icell = level_cells[i];
for ( j = 0; j < num_children; j++ ) {
cell_potential( cell_child(icell,j) ) = cell_interpolate( icell, j, VAR_POTENTIAL );
}
}
cart_free( level_cells );
end_time( WORK_TIMER );
/* update buffers */
start_time( PROLONGATE_UPDATE_TIMER );
update_buffer_level( level, prolongation_vars, 1 );
end_time( PROLONGATE_UPDATE_TIMER );
}
void compute_accelerations_particles( int level ) {
int i, j;
double a2half;
const int accel_vars[nDim] = { VAR_ACCEL, VAR_ACCEL+1, VAR_ACCEL+2 };
int neighbors[num_neighbors];
int L1, R1;
double phi_l, phi_r;
int icell;
int num_level_cells;
int *level_cells;
start_time( GRAVITY_TIMER );
start_time( PARTICLE_ACCEL_TIMER );
start_time( WORK_TIMER );
#ifdef COSMOLOGY
a2half = -0.5*abox[level]*abox[level]*cell_size_inverse[level];
#else
a2half = -0.5 * cell_size_inverse[level];
#endif
select_level( level, CELL_TYPE_LOCAL, &num_level_cells, &level_cells );
#pragma omp parallel for default(none), private(icell,j,neighbors,L1,R1,phi_l,phi_r), shared(num_level_cells,level_cells,level,cell_vars,a2half)
for ( i = 0; i < num_level_cells; i++ ) {
icell = level_cells[i];
cell_all_neighbors( icell, neighbors );
for ( j = 0; j < nDim; j++ ) {
L1 = neighbors[2*j];
R1 = neighbors[2*j+1];
if ( cell_level(L1) < level ) {
phi_l = 0.8*cell_potential(L1) + 0.2*cell_potential(icell);
} else {
phi_l = cell_potential(L1);
}
if ( cell_level(R1) < level ) {
phi_r = 0.8*cell_potential(R1)+0.2*cell_potential(icell);
} else {
phi_r = cell_potential(R1);
}
cell_accel( icell, j ) = (float)(a2half * ( phi_r - phi_l ) );
}
}
cart_free( level_cells );
end_time( WORK_TIMER );
/* update accelerations */
start_time( PARTICLE_ACCEL_UPDATE_TIMER );
update_buffer_level( level, accel_vars, nDim );
end_time( PARTICLE_ACCEL_UPDATE_TIMER );
end_time( PARTICLE_ACCEL_TIMER );
end_time( GRAVITY_TIMER );
}
void DiscreteProblem::create_matrix()
{
// remove any previous matrix
free_matrix_indices();
free_matrix_values();
// calculate the total number of DOFs
ndofs = 0;
for (int i = 0; i < neq; i++)
ndofs += spaces[i]->get_num_dofs();
if (!quiet) verbose("Ndofs: %d", ndofs);
if (!ndofs) return;
// get row and column indices of nonzero matrix elements
Page** pages = new Page*[ndofs];
memset(pages, 0, sizeof(Page*) * ndofs);
if (!quiet) { verbose("Calculating matrix sparse structure..."); begin_time(); }
precalculate_sparse_structure(pages);
// initialize the arrays Ap and Ai
Ap = (int*) malloc(sizeof(int) * (ndofs+1));
int aisize = get_num_indices(pages, ndofs);
Ai = (int*) malloc(sizeof(int) * aisize);
if (Ai == NULL) error("Out of memory. Could not allocate the array Ai.");
// sort the indices and remove duplicities, insert into Ai
int i, pos = 0, num;
for (i = 0; i < ndofs; i++)
{
Ap[i] = pos;
pos += sort_and_store_indices(pages[i], Ai + pos, Ai + aisize);
}
Ap[i] = pos;
if (!quiet) verbose(" Nonzeros: %d\n Total matrix size: %0.1lf MB\n (time: %g sec)",
pos, (double) get_matrix_size() / (1024*1024), end_time());
delete [] pages;
// shrink Ai to the actual size
int* oldAi = Ai;
Ai = (int*) realloc(Ai, sizeof(int) * pos);
if (oldAi != Ai) warn("Realloc moved Ai when shrinking."); // this should not happen
// UMFPACK: perform symbolic analysis of the matrix
if (!quiet) { verbose("Performing UMFPACK symbolic analysis..."); begin_time(); }
int status = umfpack_symbolic(ndofs, ndofs, Ap, Ai, NULL, &Symbolic, NULL, NULL);
if (status != UMFPACK_OK) umfpack_status(status);
if (!quiet) verbose(" (time: %g sec)", end_time());
equi = (double*) malloc(sizeof(double) * ndofs);
if (equi == NULL) error("Out of memory. Error allocating the equilibration vector.");
for (int i = 0; i < ndofs; i++)
equi[i] = 1.0;
is_equi = false;
}
void rtOtvetSingleSourceEddingtonTensor(int level)
{
int i, j, l, index, cell;
int num_level_cells, *level_cells;
double eps1, eps2, dr2, pos[nDim];
start_time(WORK_TIMER);
eps1 = 0.01*cell_size[rtSingleSourceLevel]*cell_size[rtSingleSourceLevel];
eps2 = 9*cell_size[rtSingleSourceLevel]*cell_size[rtSingleSourceLevel];
select_level(level,CELL_TYPE_LOCAL,&num_level_cells,&level_cells);
#pragma omp parallel for default(none), private(index,cell,pos,dr2,i,j,l), shared(level,num_level_cells,level_cells,rtSingleSourceValue,rtSingleSourcePos,eps1,eps2,cell_vars)
for(index=0; index<num_level_cells; index++)
{
cell = level_cells[index];
cell_center_position(cell,pos);
dr2 = eps1;
for(i=0; i<nDim; i++)
{
pos[i] -= rtSingleSourcePos[i];
if(pos[i] > 0.5*num_grid) pos[i] -= num_grid;
if(pos[i] < -0.5*num_grid) pos[i] += num_grid;
dr2 += pos[i]*pos[i];
}
cell_var(cell,RT_VAR_OT_FIELD) = rtSingleSourceValue/(4*M_PI*dr2);
dr2 += nDim*eps2;
for(l=j=0; j<nDim; j++)
{
for(i=0; i<j; i++)
{
cell_var(cell,rt_et_offset+l++) = pos[i]*pos[j]/dr2;
}
cell_var(cell,rt_et_offset+l++) = (eps2+pos[j]*pos[j])/dr2;
}
}
cart_free(level_cells);
end_time(WORK_TIMER);
start_time(RT_SINGLE_SOURCE_UPDATE_TIMER);
update_buffer_level(level,rtOtvetETVars,rtNumOtvetETVars);
end_time(RT_SINGLE_SOURCE_UPDATE_TIMER);
}
int readFile(int use, int dsize)
{
int p;
if (largeFile) start_time();
handle = open(testFile, O_RDONLY, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
if (handle == -1)
{
sprintf(resultchars, " Cannot open %s for reading\n", testFile);
return 0;
}
for (p=0; p<use; p++)
{
if (read(handle, dataIn, dsize) == -1)
{
sprintf(resultchars," Error reading file %s block %d\n", testFile, p+1);
return 0;
}
}
close(handle);
if (largeFile) end_time();
return 1;
}
Note<Time>::Note(const Note<Time>& copy)
: _on_event(copy._on_event, true)
, _off_event(copy._off_event, true)
{
set_id (copy.id());
assert(_on_event.buffer());
assert(_off_event.buffer());
/*
assert(copy._on_event.size == 3);
_on_event.buffer = _on_event_buffer;
memcpy(_on_event_buffer, copy._on_event_buffer, 3);
assert(copy._off_event.size == 3);
_off_event.buffer = _off_event_buffer;
memcpy(_off_event_buffer, copy._off_event_buffer, 3);
*/
assert(time() == copy.time());
assert(end_time() == copy.end_time());
assert(length() == copy.length());
assert(note() == copy.note());
assert(velocity() == copy.velocity());
assert(_on_event.channel() == _off_event.channel());
assert(channel() == copy.channel());
}
void rtInitRun()
{
#ifdef RT_TEST
frt_real Yp = 1.0e-10;
#else
frt_real Yp = constants->Yp;
#endif
frt_real Tmin = gas_temperature_floor;
frt_real D2GminH2 = rt_dust_to_gas_floor*(constants->Dsun/constants->Zsun);
frt_real CluFacH2 = rt_clumping_factor;
frt_real CohLenH2 = rt_coherence_length;
frt_real fGal = rt_uv_emissivity_stars;
frt_real fQSO = rt_uv_emissivity_quasars;
frt_intg IPOP = rt_stellar_pop;
frt_intg IREC = 0;
frt_intg IOUNIT = 81;
start_time(WORK_TIMER);
frtCall(initrun2)(&Yp,&Tmin,&D2GminH2,&CluFacH2,&CohLenH2,&fGal,&fQSO,&IPOP,&IREC,&IOUNIT);
end_time(WORK_TIMER);
#ifdef RT_TRANSFER
rtInitRunTransfer();
#endif
}
int writeFile(int use, int dsize)
{
int p;
if (largeFile) start_time();
if (useCache)
{
handle = open(testFile, O_WRONLY | O_CREAT | O_TRUNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
}
else
{
handle = open(testFile, O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT | O_SYNC,
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP| S_IROTH | S_IWOTH); // O_DIRECT | O_SYNC
}
if (handle == -1)
{
sprintf(resultchars, " Cannot open %s for writing\n", testFile);
return 0;
}
for (p=0; p<use; p++)
{
if (write(handle, dataOut, dsize) != dsize )
{
sprintf(resultchars," Error writing file %s block %d\n", testFile, p+1);
return 0;
}
}
close(handle);
if (largeFile) end_time();
return 1;
}
int main(int argc, char* argv[])
{
// Load the mesh
Mesh mesh;
H2DReader mloader;
mloader.load("domain.mesh", &mesh);
for (int i=0; i < INIT_REF_NUM; i++) mesh.refine_all_elements();
// Initialize the shapeset and the cache
H1Shapeset shapeset;
PrecalcShapeset pss(&shapeset);
// Create finite element space
H1Space space(&mesh, &shapeset);
space.set_bc_types(bc_types);
space.set_bc_values(bc_values);
space.set_uniform_order(P_INIT);
// Enumerate basis functions
space.assign_dofs();
// Initialize the weak formulation
WeakForm wf(1);
wf.add_biform(0, 0, bilinear_form, bilinear_form_ord, SYM);
wf.add_liform(0, linear_form, linear_form_ord);
wf.add_liform_surf(0, linear_form_surf, linear_form_surf_ord, 2);
// Visualize solution and mesh
ScalarView sview("Coarse solution", 0, 100, 798, 700);
OrderView oview("Polynomial orders", 800, 100, 798, 700);
// Matrix solver
UmfpackSolver solver;
// Time measurement
double cpu = 0;
begin_time();
// Solve the problem
Solution sln;
LinSystem ls(&wf, &solver);
ls.set_spaces(1, &space);
ls.set_pss(1, &pss);
ls.assemble();
ls.solve(1, &sln);
// Time measurement
cpu += end_time();
// View the solution and mesh
sview.show(&sln);
oview.show(&space);
// Print timing information
verbose("Total running time: %g sec", cpu);
// wait for all views to be closed
View::wait("Waiting for all views to be closed.");
return 0;
}
void init_ga(int num_circles)
{
char *end_time_str;
struct timespec tp1, tp2;
int idx;
if(_is_initialized)
return;
printfl(IA_INFO,
"initializing for genetic algorithm, this may take some time....");
_is_initialized = true;
circle_pool = calloc(GEN_SIZE, sizeof(struct ia_circles *));
start_time(&tp1);
for(idx = 0; idx < GEN_SIZE; idx++) {
circle_pool[idx] = calloc(1, sizeof(struct ia_circles));
init_circles(circle_pool[idx], num_circles);
}
for(idx = 0; idx < GEN_SIZE; idx++) {
//for(jdx = 0; jdx < 2; jdx++) {
// _seed_mutate(&circle_pool[idx]);
//}
refresh_circles(circle_pool[idx]);
sort_circles(circle_pool[idx]);
}
end_time_str = end_time(&tp1, &tp2, "time");
printfi("%s\nsee, that didn't take too long, did it?\n", end_time_str);
free(end_time_str);
}
void rtInitStep(double dt)
{
frt_real uDen = units->number_density;
frt_real uLen = units->length;
frt_real uTime = units->time;
frt_real dtCode = dt;
#ifdef COSMOLOGY
frt_real aExp = abox[min_level];
frt_real daExp = abox_from_tcode(tl[min_level]+dt) - abox[min_level];
frt_real HExp = Hubble(aExp)/units->time;
#else
frt_real aExp = 1.0;
frt_real daExp = 0.0;
frt_real HExp = 0.0;
#endif
start_time(WORK_TIMER);
frtCall(stepbegin)(&uDen,&uLen,&uTime,&aExp,&HExp,&daExp,&dtCode);
end_time(WORK_TIMER);
#ifdef RT_TRANSFER
rtInitStepTransfer();
#endif
rtUpdateTables();
#ifdef RT_DEBUG
switch(rt_debug.Mode)
{
case 1:
{
int i, cell;
cell = cell_find_position(rt_debug.Pos);
cart_debug("In cell-level debug for cell %d/%d",cell,cell_level(cell));
cart_debug("RT_HVAR_OFFSET: %d",RT_HVAR_OFFSET);
#ifdef RT_VAR_SOURCE
cart_debug("RT_VAR_SOURCE: %d",RT_VAR_SOURCE);
#endif
cart_debug("rt_grav_vars_offset: %d",rt_grav_vars_offset);
#ifdef RT_TRANSFER
cart_debug("rt_num_vars: %d",rt_num_vars);
#if (RT_TRANSFER_METHOD == RT_METHOD_OTVET)
cart_debug("RT_VAR_OT_FIELD: %d",RT_VAR_OT_FIELD);
cart_debug("rt_et_offset: %d",rt_et_offset);
cart_debug("rt_field_offset: %d",rt_field_offset);
#endif
#endif
for(i=0; i<num_vars; i++)
{
cart_debug("Var[%d] = %g",i,cell_var(cell,i));
}
break;
}
}
#endif /* RT_DEBUG */
}
void Control::initTime()
{
QSqlQuery query;
QDateTime start_date_time;
query.exec("select min(DATE),min(TIME) from DATAS");
if(query.next()){
int min_date = query.value(0).toInt();
int min_time = query.value(1).toInt();
int year = min_date / 10000;
int month = min_date % 10000 / 100;
int day = min_date % 100;
int h = min_time / 10000;
QTime start_time(h,0);
QDate start_date(2000 +year,month,day);
start_date_time = QDateTime(start_date,start_time);
}
query.exec("select max(DATE),max(TIME) from DATAS");
QDateTime end_date_time;
if(query.next()){
int max_date = query.value(0).toInt();
int max_time = query.value(1).toInt();
int year = max_date / 10000;
int month = max_date % 10000 / 100;
int day = max_date % 100;
int h = max_time / 10000;
QTime end_time(h,0);
QDate end_date(2000 +year,month,day);
end_date_time = QDateTime(end_date,end_time);
}
ui->startDateTimeEdit->setDisplayFormat("yyyy-M-d HH");
ui->endDateTimeEdit->setDisplayFormat("yyyy-M-d HH");
ui->startDateTimeEdit->setMinimumDateTime(start_date_time);
ui->startDateTimeEdit->setMaximumDateTime(end_date_time);
ui->endDateTimeEdit->setMinimumDateTime(start_date_time);
ui->endDateTimeEdit->setMaximumDateTime(end_date_time);
ui->startDateTimeEdit_2->setDisplayFormat("yyyy-M-d HH");
ui->endDateTimeEdit_2->setDisplayFormat("yyyy-M-d HH");
ui->startDateTimeEdit_2->setMinimumDateTime(start_date_time);
ui->startDateTimeEdit_2->setMaximumDateTime(end_date_time);
ui->endDateTimeEdit_2->setMinimumDateTime(start_date_time);
ui->endDateTimeEdit_2->setMaximumDateTime(end_date_time);
ui->startDateTimeEdit_3->setDisplayFormat("yyyy-M-d HH");
ui->endDateTimeEdit_3->setDisplayFormat("yyyy-M-d HH");
ui->startDateTimeEdit_3->setMinimumDateTime(start_date_time);
ui->startDateTimeEdit_3->setMaximumDateTime(end_date_time);
ui->endDateTimeEdit_3->setMinimumDateTime(start_date_time);
ui->endDateTimeEdit_3->setMaximumDateTime(end_date_time);
ui->startDateTimeEdit_4->setDisplayFormat("yyyy-M-d HH");
ui->endDateTimeEdit_4->setDisplayFormat("yyyy-M-d HH");
ui->startDateTimeEdit_4->setMinimumDateTime(start_date_time);
ui->startDateTimeEdit_4->setMaximumDateTime(end_date_time);
ui->endDateTimeEdit_4->setMinimumDateTime(start_date_time);
ui->endDateTimeEdit_4->setMaximumDateTime(end_date_time);
}
void rtAfterAssignDensity2(int level, int num_level_cells, int *level_cells)
{
start_time(RT_AFTER_DENSITY_TIMER);
#ifdef RT_TRANSFER
rtAfterAssignDensityTransfer(level,num_level_cells,level_cells);
#endif
end_time(RT_AFTER_DENSITY_TIMER);
}
void rtLevelUpdate(int level)
{
start_time(RT_LEVEL_UPDATE_TIMER);
#ifdef RT_TRANSFER
rtLevelUpdateTransfer(level);
#endif
end_time(RT_LEVEL_UPDATE_TIMER);
}
/** Nonadaptive solver.*/
void solveNonadaptive(Mesh &mesh, NonlinSystem &nls,
Solution &Cp, Solution &Ci, Solution &phip, Solution &phii) {
begin_time();
//VectorView vview("electric field [V/m]", 0, 0, 600, 600);
ScalarView Cview("Concentration [mol/m3]", 0, 0, 800, 800);
ScalarView phiview("Voltage [V]", 650, 0, 600, 600);
#ifdef CONT_OUTPUT
phiview.show(&phii);
Cview.show(&Ci);
Cview.wait_for_keypress();
#endif
Solution Csln, phisln;
for (int n = 1; n <= NSTEP; n++) {
#ifdef VERBOSE
info("\n---- Time step %d ----", n);
#endif
int it = 1;
double res_l2_norm;
do {
#ifdef VERBOSE
info("\n -------- Time step %d, Newton iter %d --------\n", n, it);
#endif
it++;
nls.assemble();
nls.solve(2, &Csln, &phisln);
res_l2_norm = nls.get_residuum_l2_norm();
#ifdef VERBOSE
info("Residuum L2 norm: %g\n", res_l2_norm);
#endif
Ci.copy(&Csln);
phii.copy(&phisln);
} while (res_l2_norm > NEWTON_TOL);
#ifdef CONT_OUTPUT
phiview.show(&phii);
Cview.show(&Ci);
#endif
phip.copy(&phii);
Cp.copy(&Ci);
}
verbose("\nTotal run time: %g sec", end_time());
Cview.show(&Ci);
phiview.show(&phii);
//MeshView mview("small.mesh", 100, 30, 800, 800);
//mview.show(&mesh);
View::wait();
}
void copy_potential( int level ) {
int i;
int icell;
int num_level_cells;
int *level_cells;
start_time( GRAVITY_TIMER );
start_time( WORK_TIMER );
select_level( level, CELL_TYPE_ANY, &num_level_cells, &level_cells );
#pragma omp parallel for default(none), private(i,icell), shared(num_level_cells,level_cells,cell_vars)
for ( i = 0; i < num_level_cells; i++ ) {
icell = level_cells[i];
cell_potential_hydro(icell) = cell_potential(icell);
}
cart_free( level_cells );
end_time( WORK_TIMER );
end_time( GRAVITY_TIMER );
}
/* This function can be called more than once per top level step */
void rtUpdateTables()
{
#ifdef RT_TRANSFER
int i;
frt_real rfAvg[rt_num_fields];
for(i=0; i<rt_num_fields; i++) rfAvg[i] = rtAvgRF[i].Value;
#else
frt_real *rfAvg = NULL;
#endif
start_time(RT_TABLES_TIMER);
start_time(WORK_TIMER);
/* Fill in the tables */
frtCall(updatetables)(rfAvg);
end_time(WORK_TIMER);
end_time(RT_TABLES_TIMER);
}
void rtGlobalUpdate(int top_level, MPI_Comm level_com)
{
start_time(RT_GLOBAL_UPDATE_TIMER);
#ifdef RT_TRANSFER
rtGlobalUpdateTransfer(top_level,level_com);
#endif
//rtUpdateTables(top_level,level_com);
end_time(RT_GLOBAL_UPDATE_TIMER);
}
void rtAfterAssignDensity1(int level)
{
int num_level_cells;
int *level_cells;
start_time(RT_AFTER_DENSITY_TIMER);
#ifdef RT_TRANSFER
/* assumes buffer gas density is up to date */
start_time( WORK_TIMER );
select_level(level,CELL_TYPE_ANY,&num_level_cells,&level_cells);
end_time( WORK_TIMER );
rtAfterAssignDensityTransfer(level,num_level_cells,level_cells);
start_time( WORK_TIMER );
cart_free(level_cells);
end_time( WORK_TIMER );
#endif
end_time(RT_AFTER_DENSITY_TIMER);
}
void interpolate_potential( int level ) {
int i;
int icell;
int num_level_cells;
int *level_cells;
double dtdt2;
start_time( GRAVITY_TIMER );
start_time( WORK_TIMER );
/*
// NG: dtl_old may not be set in the first time-step, but then
// cell_potential = cell_potential_hydro
*/
if(dtl_old[level] > 0.1*dtl[level])
{
dtdt2 = 0.5 * dtl[level]/dtl_old[level];
}
else
{
dtdt2 = 0;
}
select_level( level, CELL_TYPE_ANY, &num_level_cells, &level_cells );
#pragma omp parallel for default(none), private(i,icell), shared(num_level_cells,level_cells,cell_vars,dtdt2)
for ( i = 0; i < num_level_cells; i++ ) {
icell = level_cells[i];
cell_potential_hydro(icell) = cell_potential(icell) +
( cell_potential(icell) - cell_potential_hydro(icell) ) * dtdt2;
}
cart_free( level_cells );
end_time( WORK_TIMER );
end_time( GRAVITY_TIMER );
}
void solve_poisson( int level, int flag ) {
const int potential_vars[1] = { VAR_POTENTIAL };
cart_assert( level >= min_level && level <= max_level );
start_time( GRAVITY_TIMER );
if ( level == min_level ) {
root_grid_fft_exec(VAR_TOTAL_MASS,1,potential_vars,root_grid_fft_gravity_worker);
} else {
relax( level, flag );
}
end_time( GRAVITY_TIMER );
}
const Note<Time>&
Note<Time>::operator=(const Note<Time>& other)
{
_on_event = other._on_event;
_off_event = other._off_event;
assert(time() == other.time());
assert(end_time() == other.end_time());
assert(length() == other.length());
assert(note() == other.note());
assert(velocity() == other.velocity());
assert(_on_event.channel() == _off_event.channel());
assert(channel() == other.channel());
return *this;
}
void star_particle_feedback(int level, int time_multiplier) {
int i;
int ipart;
int iter_cell;
int num_level_cells;
int *level_cells;
double t_next;
start_time( WORK_TIMER );
setup_star_formation_feedback(level);
t_next = tl[level] + time_multiplier*dtl[level];
select_level( level, CELL_TYPE_LOCAL | CELL_TYPE_LEAF, &num_level_cells, &level_cells );
#ifndef COMPILER_GCC
/* Get compiler segfault under GCC */
#ifdef STAR_PARTICLE_TYPES
#pragma omp parallel for default(none), private(iter_cell,ipart), shared(num_level_cells,level_cells,cell_particle_list,particle_level,level,particle_t,t_next,particle_id,particle_species_indices,num_particle_species,particle_list_next, sf_feedback_particle,star_particle_type), schedule(dynamic)
#else
#pragma omp parallel for default(none), private(iter_cell,ipart), shared(num_level_cells,level_cells,cell_particle_list,particle_level,level,particle_t,t_next,particle_id,particle_species_indices,num_particle_species,particle_list_next, sf_feedback_particle), schedule(dynamic)
#endif
#endif
for ( i = 0; i < num_level_cells; i++ ) {
iter_cell = level_cells[i];
ipart = cell_particle_list[iter_cell];
while ( ipart != NULL_PARTICLE ) {
if ( particle_is_star(ipart) && particle_t[ipart] < t_next - 0.5*dtl[max_level]
#ifdef STAR_PARTICLE_TYPES
&& ( star_particle_type[ipart] == STAR_TYPE_NORMAL
|| star_particle_type[ipart] == STAR_TYPE_STARII
|| star_particle_type[ipart] == STAR_TYPE_FAST_GROWTH)
#endif /* STAR_PARTICLE_TYPES */
) {
sf_feedback_particle->hydro_feedback(level,iter_cell,ipart,t_next);
}
ipart = particle_list_next[ipart];
}
}
cart_free(level_cells);
end_time( WORK_TIMER );
}
// ------------------------------------------------------------------------
//
// ------------------------------------------------------------------------
void SmInitMetaModelFromPN( ILTAStream *strm , MetaModel &metaModel,
CParseNode *pnroot,
CLTATranslStatus & status )
{
// give pnode processors a target
s_animsetcmd.m_MetaModel = & metaModel ;
s_hierarchycmd.m_MetaModel = & metaModel ;
s_shapecmd.m_MetaModel = & metaModel ;
// set up symbol table
CExecPN::s_ProcFnTable["animset"] = & s_animsetcmd ;
CExecPN::s_ProcFnTable["hierarchy"] = & s_hierarchycmd ;
CExecPN::s_ProcFnTable["shape"] = & s_shapecmd ;
// apply cmds to tree.
start_time();
__BuildParseTree( strm, pnroot );
end_time();
}
void State::create_rows()
{
for (auto &block : blocks)
{
if (block.parent_name)
{
auto it = std::find_if(blocks.begin(), blocks.end(), [&block](const Block &other)
{
return other.name == *block.parent_name;
});
if (it == blocks.end())
throw std::runtime_error("State::create_rows: no parent found");
block.start_time = it->end_time();
}
block.create_rows(teams.size());
}
}
void rtAfterAssignDensityTransfer(int level, int num_level_cells, int *level_cells)
{
#ifdef RT_VAR_SOURCE
int i;
#ifdef PARTICLES
/*
// If we have a source field that was set inside density(...),
// turn the mass per cell into density.
*/
start_time( WORK_TIMER );
#pragma omp parallel for default(none), private(i), shared(level,num_level_cells,level_cells,cell_vars)
for(i=0; i<num_level_cells; i++)
{
cell_rt_source(level_cells[i]) *= cell_volume_inverse[level];
}
end_time( WORK_TIMER );
#else /* PARTICLES */
#ifdef RT_SINGLE_SOURCE
/*
// Set the source field from a single source
*/
rtTransferAssignSingleSourceDensity(level);
#else /* RT_SINGLE_SOURCE */
#error "Invalid set of switches: either PARTICLES or RT_SINGLE_SOURCE must be defined."
#endif /* RT_SINGLE_SOURCE */
#endif /* PARTICLES */
#if (RT_TRANSFER_METHOD == RT_METHOD_OTVET)
/* Need only local cells */
rtAfterAssignDensityTransferOtvet(level,num_cells_per_level[level],level_cells);
#endif
#endif /* RT_VAR_SOURCE */
}
int Hes_Emu::cpu_done()
{
check( time() >= end_time() ||
(!(r.status & i_flag_mask) && time() >= irq_time()) );
if ( !(r.status & i_flag_mask) )
{
hes_time_t present = time();
if ( irq.timer <= present && !(irq.disables & timer_mask) )
{
timer.fired = true;
irq.timer = future_hes_time;
irq_changed(); // overkill, but not worth writing custom code
#if GME_FRAME_HOOK_DEFINED
{
unsigned const threshold = period_60hz / 30;
unsigned long elapsed = present - last_frame_hook;
if ( elapsed - period_60hz + threshold / 2 < threshold )
{
last_frame_hook = present;
GME_FRAME_HOOK( this );
}
}
#endif
return 0x0A;
}
if ( irq.vdp <= present && !(irq.disables & vdp_mask) )
{
// work around for bugs with music not acknowledging VDP
//run_until( present );
//irq.vdp = future_hes_time;
//irq_changed();
#if GME_FRAME_HOOK_DEFINED
last_frame_hook = present;
GME_FRAME_HOOK( this );
#endif
return 0x08;
}
}
return 0;
}
void HeaderManipulation::publishMsg(const topic_tools::ShapeShifter &msg, const ros::Time &msg_in_time)
{
ROS_DEBUG("HeaderManipulation publishMsg Thread started with timestamp %f", msg_in_time.toSec());
ros::Time end_time(ros::Time::now());
ros::Time last_time;
config_mutex_.lock();
ros::Time time_to_pub(msg_in_time + msg_delay_);
config_mutex_.unlock();
do
{
last_time = end_time;
ROS_DEBUG("waiting to publish msg from %f at %f", msg_in_time.toSec(), time_to_pub.toSec());
if (end_time > time_to_pub)
{
boost::mutex::scoped_lock pub_lock(pub_mutex_);
ROS_DEBUG("publishing msg which should be held back till: %f", time_to_pub.toSec());
generic_pub_.publish(msg);
return;
}
boost::mutex::scoped_lock config_lock(config_mutex_);
publish_retry_rate_.sleep();
time_to_pub = msg_in_time + msg_delay_;
end_time = ros::Time::now();
} while (last_time <= end_time);
ROS_WARN("Detected jump back in time. Dropping msg. last: %f, end %f",
last_time.toSec(), end_time.toSec());
return;
}
