static void *client_thread_main(void *arg){ /* * The *arg is a private copy of the ce. This function must * free(ce) it when it is finished, but it must _not_ try to * delete anything else from the ce. * We used to set the cancellation state to DISABLED and then renabled * after the loop in the loop, to avoid cancelling the thread while * it holds a mutex locked. But this not appropriate if we let the * g.client_queue_read_timeout_ms be a configurable parameter: the user * can set this very high, and the thread would not be canceled until * that timer expires. [The alternative would be to write a wrapper * over connqueue_rcv() that disbales the cancellation and calls * connqueue_rcv() with a short (i.e., 1 second) wait time * and retries any number of times.] * * See cleanup(). */ /* int cancel_state; */ /* int status = 0; */ struct conn_element_st *ce = (struct conn_element_st*)arg; pthread_cleanup_push(cleanup, arg); while((get_quit_flag() == 0) && (conn_element_get_exit_flag(ce) == 0)){ pthread_testcancel(); /* * status = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cancel_state); */ periodic(ce); loop(ce); /* * status = pthread_setcancelstate(cancel_state, &cancel_state); */ } pthread_cleanup_pop(1); return(NULL); }
void Robot::OperatorControl(void) { printf("Operator Mode"); while(IsOperatorControl() && IsEnabled()) { /* Collect sensor data */ periodic(); drive->TankDrive(leftStick, rightStick); if(lstick->GetRawButton(1)) { shifter->Set(DoubleSolenoid::kForward); } else { shifter->Set(DoubleSolenoid::kReverse); } Wait(0.005); // wait for a motor update time } }
void naive_proceed() { ++global_clock; auto lap = [](Real ar[NX][NY][NZ],int x, int y, int z) { auto ret = periodic(ar, x-1, y, z) + periodic(ar, x+1, y, z) + periodic(ar, x, y-1, z) + periodic(ar, x, y+1, z) + periodic(ar, x, y, z-1) + periodic(ar, x, y, z+1) - 6*ar[x][y][z]; return ret / dx / dx; }; #pragma omp parallel for collapse(2) for (int x=0;x<NX;++x) { for (int y=0;y<NY;++y) { for (int z=0;z<NZ;++z) { auto u = U[x][y][z], v = V[x][y][z]; auto du_dt = -Fe * u*v*v + Fu*(1-u) + Du * lap(U,x,y,z); auto dv_dt = Fe * u*v*v - Fv*v + Dv * lap(V,x,y,z); U_other[x][y][z] = U[x][y][z] + dt*du_dt; V_other[x][y][z] = V[x][y][z] + dt*dv_dt; } } } for (int x=0;x<NX;++x) { for (int y=0;y<NY;++y) { for (int z=0;z<NZ;++z) { U[x][y][z]=U_other[x][y][z]; } } } for (int x=0;x<NX;++x) { for (int y=0;y<NY;++y) { for (int z=0;z<NZ;++z) { V[x][y][z]=V_other[x][y][z]; } } } }
inline Timers::id_t Timers::periodic(duration_t period, handler_t handler) { return periodic(period, period, handler); }
inline Timers::id_t Timers::oneshot(duration_t when, handler_t handler) { return periodic(when, std::chrono::milliseconds(0), handler); }
int main(int argc, char **argv) { static char fname[] = "res/main"; int nready; int maxfd; int i; char *sp; char *pathname = NULL; int didSomething = 0; char exbuf; time_t thisPeriodic, lastPeriodic = 0, timeDiff; fd_set rm, wm, em; int sbdPty = FALSE; char *sbdClHost = NULL; ushort sbdClPort = 0; char **sbdArgv = NULL; int selectError = 0; _i18n_init(I18N_CAT_RES); saveDaemonDir_(argv[0]); for (i=1; i<argc; i++) { if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) { pathname = argv[i+1]; putEnv("LSF_ENVDIR",pathname); break; } } if (pathname == NULL) { if ((pathname = getenv("LSF_ENVDIR")) == NULL) pathname = LSETCDIR; } if (argc > 1) { if (!strcmp(argv[1],"-V")) { fputs(_LS_VERSION_, stderr); exit(0); } } if ((ls_readconfenv(resConfParams, NULL) < 0) || (initenv_(resParams, pathname) < 0) ) { if ((sp = getenv("LSF_LOGDIR")) != NULL) resParams[LSF_LOGDIR].paramValue = sp; ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1), resParams[LSF_LOG_MASK].paramValue); ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_MM, fname, "initenv_", pathname); ls_syslog(LOG_ERR, I18N_Exiting); exit(-1); } restart_argc = argc; restart_argv = argv; for (i=1; i<argc; i++) { if (strcmp(argv[i], "-d") == 0 && argv[i+1] != NULL) { pathname = argv[i+1]; i++; continue; } if (strcmp(argv[i], "-1") == 0) { debug = 1; continue; } if (strcmp(argv[i], "-2") == 0) { debug = 2; continue; } if (strcmp(argv[i], "-PTY_FIX") == 0) { printf("PTY_FIX"); exit(0); } if ( (strcmp(argv[i], "-j") == 0) && (argv[i+1] != NULL) ) { lsbJobStarter = argv[++i]; continue; } if (strcmp(argv[i], "-P") == 0) { sbdPty = TRUE; continue; } if (strcmp(argv[i], "-i") == 0) { sbdFlags |= SBD_FLAG_STDIN; continue; } if (strcmp(argv[i], "-o") == 0) { sbdFlags |= SBD_FLAG_STDOUT; continue; } if (strcmp(argv[i], "-e") == 0) { sbdFlags |= SBD_FLAG_STDERR; continue; } if (strcmp(argv[i], "-m") == 0 && argv[i+1] != NULL) { sbdClHost = argv[i+1]; i++; sbdMode = TRUE; continue; } if (strcmp(argv[i], "-p") == 0 && argv[i+1] != NULL) { sbdClPort = atoi(argv[i+1]); i++; sbdMode = TRUE; continue; } if (argv[i][0] != '-') { sbdMode = TRUE; sbdArgv = argv + i; break; } usage(argv[0]); } if (sbdMode) { if (sbdClHost == NULL || sbdArgv == NULL) { usage(argv[0]); exit(-1); } if (sbdClPort) { sbdFlags |= SBD_FLAG_TERM; } else { sbdFlags |= SBD_FLAG_STDIN | SBD_FLAG_STDOUT | SBD_FLAG_STDERR; } } else { if (debug < 2) for (i = sysconf(_SC_OPEN_MAX) ; i >= 0 ; i--) close(i); } if (resParams[LSF_SERVERDIR].paramValue == NULL) { ls_openlog("res", resParams[LSF_LOGDIR].paramValue, (debug > 1), resParams[LSF_LOG_MASK].paramValue); ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5001, "LSF_SERVERDIR not defined in %s/lsf.conf: %M; res exiting"), /* catgets 5001 */ pathname); resExit_(-1); } if (! debug && resParams[LSF_RES_DEBUG].paramValue != NULL) { debug = atoi(resParams[LSF_RES_DEBUG].paramValue); if (debug <= 0) debug = 1; } getLogClass_(resParams[LSF_DEBUG_RES].paramValue, resParams[LSF_TIME_RES].paramValue); if (getuid() == 0 && debug) { if (sbdMode) { debug = 0; } else { ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE, resParams[LSF_LOG_MASK].paramValue); ls_syslog(LOG_ERR, I18N(5005,"Root cannot run RES in debug mode ... exiting."));/*catgets 5005 */ exit(-1); } } if (debug > 1) ls_openlog("res", resParams[LSF_LOGDIR].paramValue, TRUE, "LOG_DEBUG"); else { ls_openlog("res", resParams[LSF_LOGDIR].paramValue, FALSE, resParams[LSF_LOG_MASK].paramValue); } if (logclass & (LC_TRACE | LC_HANG)) ls_syslog(LOG_DEBUG, "%s: logclass=%x", fname, logclass); ls_syslog(LOG_DEBUG, "%s: LSF_SERVERDIR=%s", fname, resParams[LSF_SERVERDIR].paramValue); init_res(); initSignals(); periodic(0); if (sbdMode) { lsbJobStart(sbdArgv, sbdClPort, sbdClHost, sbdPty); } maxfd = FD_SETSIZE; for (;;) { struct timeval *timep; struct timeval timeout; loop: didSomething = 0; for (i = 0; i < child_cnt; i++) { if (children[i]->backClnPtr == NULL && !FD_IS_VALID(conn2NIOS.sock.fd) && children[i]->running == 0) { delete_child (children[i]); } } if (logclass & LC_TRACE) { ls_syslog(LOG_DEBUG,"\ %s: %s Res child_res=<%d> child_go=<%d> child_cnt=<%d> client_cnt=<%d>", fname, ((child_res) ? "Application" : "Root") , child_res, child_go, child_cnt, client_cnt); if (child_cnt == 1 && children != NULL && children[0] != NULL) { dumpChild(children[0], 1, "in main()"); } } if (child_res && child_go && child_cnt == 0 && client_cnt == 0) { if (debug > 1) printf (" \n Child <%d> Retired! \n", (int)getpid()); if (logclass & LC_TRACE) { ls_syslog(LOG_DEBUG,"\ %s: Application Res is exiting.....", fname); } millisleep_(5000); if (sbdMode) { close(1); close(2); exit(lastChildExitStatus); } resExit_(EXIT_NO_ERROR); }
/** \brief Return a ParameterList filled with all valid parameters, * documentation strings, default values, and validators */ RCP< const ParameterList > getValidParameters() { static RCP< const ParameterList > result; if ( result.is_null() ) { // Allocate a new non-const ParameterList ParameterList* plist = new ParameterList; //////////////////////////////////////////////////////////////// // "comm dimensions" parameter applies to MDComm, MDMap and MDVector //////////////////////////////////////////////////////////////// RCP< EnhancedNumberValidator< int > > axisCommNumber = rcp(new EnhancedNumberValidator< int >()); axisCommNumber->setMin(-1); RCP< const EnhancedNumberValidator< int > > constAxisCommNumber = rcp_const_cast< EnhancedNumberValidator< int > >(axisCommNumber); RCP< const ParameterEntryValidator > axisCommValidator = rcp< const ParameterEntryValidator > (new ArrayNumberValidator< int >(constAxisCommNumber)); Array< int > commDims(1); commDims[0] = -1; plist->set("comm dimensions", commDims, "An array of ints that specifies the size of the " "MDComm along each axis. If the 'dimensions' parameter is " "present, then the length of that parameter determines the " "number of dimensions. If 'dimensions' is not present, then " "the length of this parameter determines the number of " "dimensions. If the length of this parameter is shorter than " "the number of dimensions, then this parameter is extended with " "values of -1. A negative value tells Domi to fill in a " "logical value based on the total number of processors.", axisCommValidator); //////////////////////////////////////////////////////////////// // "periodic" parameter applies to MDComm, MDMap, and MDVector //////////////////////////////////////////////////////////////// RCP< EnhancedNumberValidator< int > > periodicNumber = rcp(new EnhancedNumberValidator< int >()); periodicNumber->setMin(0); periodicNumber->setMax(1); RCP< const EnhancedNumberValidator< int > > constPeriodicNumber = rcp_const_cast< EnhancedNumberValidator< int > >(periodicNumber); RCP< const ParameterEntryValidator > periodicValidator = rcp< const ParameterEntryValidator > //(new ScalarOrArrayNumberValidator< int >(constPeriodicNumber)); (new ArrayNumberValidator< int >(constPeriodicNumber)); //int periodic = 0; Array< int > periodic(1); periodic[0] = 0; plist->set("periodic", periodic, "A scalar or an array of int flags specifying whether axes are " "periodic. If a scalar is given, then all axes share that " "periodicity flag. If an array is given and it is shorter than " "the length of commDims array, then the unspecified " "entries are given a default value of zero (not " "periodic).", periodicValidator); //////////////////////////////////////////////////////////////// // "dimensions" parameter applies to MDComm, MDMap and MDVector //////////////////////////////////////////////////////////////// RCP< EnhancedNumberValidator< dim_type > > dimensionNumber = rcp(new EnhancedNumberValidator< dim_type >()); dimensionNumber->setMin(0); RCP< const EnhancedNumberValidator< dim_type > > constDimensionNumber = rcp_const_cast< EnhancedNumberValidator< dim_type > >(dimensionNumber); RCP< const ParameterEntryValidator > dimensionValidator = rcp< const ParameterEntryValidator > (new ArrayNumberValidator< dim_type >(constDimensionNumber)); Array< dim_type > dimensions(1); dimensions[0] = 0; plist->set("dimensions", dimensions, "An array of ordinals specifying the global dimensions of " "the MDMap. If present for the MDComm constructor, the length " "of this parameter will set the number of dimensions. If not " "present for the MDComm constructor, the number of dimensions " "will be set by the length of the 'axis comm szies' parameter.", dimensionValidator); // Both boundary pad and communication pad use the same number and // array validators, so just construct one EnhancedNumberValidator // and one ArrayNumberValidator. int pad = 0; Array< int > pads; RCP< EnhancedNumberValidator< int > > padNumberValidator = rcp(new EnhancedNumberValidator< int >()); padNumberValidator->setMin(0); RCP< const EnhancedNumberValidator< int > > constPadNumberValidator = rcp_const_cast< EnhancedNumberValidator< int > >(padNumberValidator); RCP< const ParameterEntryValidator > padArrayValidator = rcp< const ParameterEntryValidator > (new ArrayNumberValidator< int >(constPadNumberValidator)); //////////////////////////////////////////////////////////////// // "boundary pad size" parameter applies to MDMap and MDVector //////////////////////////////////////////////////////////////// plist->set("boundary pad size", pad, "An int that specifies the boundary padding size for all axes.", padNumberValidator); //////////////////////////////////////////////////////////////// // "boundary pad sizes" parameter applies to MDMap and MDVector //////////////////////////////////////////////////////////////// plist->set("boundary pad sizes", pads, "An array of ints specifying the size of the boundary padding " "along each axis. All unspecified entries take the value of " "the 'boundary pad size' parameter, which defaults to zero.", padArrayValidator); //////////////////////////////////////////////////////////////// // "communication pad size" parameter applies to MDMap and MDVector //////////////////////////////////////////////////////////////// plist->set("communication pad size", pad, "An int that specifies the communication padding size for all " "axes.", padNumberValidator); //////////////////////////////////////////////////////////////// // "communication pad sizes" parameter applies to MDMap and MDVector //////////////////////////////////////////////////////////////// plist->set("communication pad sizes", pads, "An array of ints specifying the size of the communication " "padding along each axis. All unspecified entries take the " "value of the 'communication pad size' parameter, which " "defaults to zero.", padArrayValidator); //////////////////////////////////////////////////////////////// // "layout" parameter applies to MDMap and MDVector //////////////////////////////////////////////////////////////// string layout = "Default"; Array< string > layoutOpts(tuple(string("C Order"), string("Fortran Order"), string("Row Major"), string("Column Major"), string("Last Index Fastest"), string("First Index Fastest"), string("Default"))); Array< string > layoutDocs(tuple(string("C storage order (last index varies " "fastest)"), string("Fortran storage order (first index " "varies fastest)"), string("Row major storage order (last index " "varies fastest)"), string("Column major storage order (first " "index varies fastest)"), string("Last index varies fastest"), string("First index varies fastest"), string("Fortran storage order"))); Array< int > layoutVals(tuple(0, 1, 0, 1, 0, 1, 1)); RCP< const ParameterEntryValidator > layoutValidator = rcp(new StringToIntegralParameterEntryValidator< int > (layoutOpts(), layoutDocs(), layoutVals(), string("Default"), false)); plist->set("layout", layout, "A string indicating how the data is laid out in memory. " "Default is currently set to Fortran order.", layoutValidator); //////////////////////////////////////////////////////////////// // "leading dimension" parameter applies to MDVector //////////////////////////////////////////////////////////////// plist->set("leading dimension", pad, "Use the 'leading dimension' parameter to specify multiple " "degrees of freedom at each MDMap index. This increases the " "dimension of the MDVector by one, and the new degrees of " "freedom are accessed with the first index.", padNumberValidator); //////////////////////////////////////////////////////////////// // "trailing dimension" parameter applies to MDVector //////////////////////////////////////////////////////////////// plist->set("trailing dimension", pad, "Use the 'trailing dimension' parameter to specify multiple " "degrees of freedom at each MDMap index. This increases the " "dimension of the MDVector by one, and the new degrees of " "freedom are accessed with the last index.", padNumberValidator); // ParameterList construction is done, so wrap it with an RCP< // const ParameterList > result.reset(plist); } return result; }
SearchEngine::SearchEngine() { //read book records from book.txt and take in 10 pipe separated fields ifstream book("book.txt"); while(!getline(book, callNumber,'|').eof()) { getline(book, title,'|'); getline(book, subjects,'|'); getline(book, author,'|'); getline(book, description,'|'); getline(book, publisher,'|'); getline(book, city,'|'); getline(book, year,'|'); getline(book, series,'|'); getline(book, notes, '\n'); Book* objBook = new Book(callNumber, title, subjects, author, description, publisher, city, year, series, notes); CardCatalog.push_back(objBook); } book.close(); //read periodic records from periodic.txt and take in 12 pipe separated fields ifstream periodic("periodic.txt"); while(!getline(periodic, periodic_callNumber,'|').eof()) { getline(periodic, periodic_title,'|'); getline(periodic, periodic_subjects,'|'); getline(periodic, periodic_author,'|'); getline(periodic, periodic_description,'|'); getline(periodic, periodic_publisher,'|'); getline(periodic, periodic_publishing_history,'|'); getline(periodic, periodic_series,'|'); getline(periodic, periodic_notes,'|'); getline(periodic, periodic_related_titles,'|'); getline(periodic, periodic_other_forms_of_title,'|'); getline(periodic, periodic_govt_doc_number, '\n'); Periodic* objPeriodic = new Periodic(periodic_callNumber, periodic_title, periodic_subjects, periodic_author, periodic_description, periodic_publisher, periodic_publishing_history, periodic_series, periodic_notes, periodic_related_titles, periodic_other_forms_of_title, periodic_govt_doc_number); CardCatalog.push_back(objPeriodic); } periodic.close(); //read video records from video.txt and take in 8 pipe separated fields ifstream video("video.txt"); while(!getline(video, video_callNumber,'|').eof()) { getline(video, video_title,'|'); getline(video, video_subjects,'|'); getline(video, video_description,'|'); getline(video, video_distributor,'|'); getline(video, video_notes,'|'); getline(video, video_series,'|'); getline(video, video_label, '\n'); Video* objVideo = new Video(video_callNumber, video_title, video_subjects, video_description, video_distributor, video_notes, video_series, video_label); CardCatalog.push_back(objVideo); } video.close(); //read film records from periodic.txt and take in 6 pipe separated fields ifstream film("film.txt"); while(!getline(film, film_callNumber,'|').eof()) { getline(film, film_title,'|'); getline(film, film_subjects,'|'); getline(film, film_director,'|'); getline(film, film_notes,'|'); getline(film, film_year, '\n'); Film* objFilm = new Film(film_callNumber, film_title, film_subjects, film_director, film_notes, film_year); CardCatalog.push_back(objFilm); } film.close(); }
/* * UtilsSuite.cpp * * Created on: 29 Sep 2012 * Author: Patrick */ #include "catch.hpp" #include "ColourU.h" TEST_CASE("Utils/ColourPeriodic", "tests the output of the periodic function") { CHECK( periodic(0) == 1.0 ); CHECK( abs(periodic(0.5)) < 1e-10 ); CHECK( periodic(1) == 1.0 ); } TEST_CASE("Utils/ColourRainbow", "tests the colour output") { CHECK(rainbowColour(0) == 46026); CHECK(rainbowColour(250) == 16665396); CHECK(rainbowColour(500) == 46026); }
void get_solution_at(int t, int x, int y, int z, Real &u, Real &v) { if(global_clock > t) fill_initial_condition(); while(global_clock < t) naive_proceed(); u = periodic(U,x,y,z); v = periodic(V,x,y,z); }
void App::Init_Periodic() { auto storage = storage_; auto now = std::time(nullptr); Schedule( nym_publish_interval_, [storage]()-> void{ NymLambda nymLambda([](const serializedCredentialIndex& nym)-> void { App::Me().DHT().Insert(nym); }); storage->MapPublicNyms(nymLambda); }, now); Schedule( nym_refresh_interval_, [storage]()-> void{ NymLambda nymLambda([](const serializedCredentialIndex& nym)-> void { App::Me().DHT().GetPublicNym(nym.nymid()); }); storage->MapPublicNyms(nymLambda); }, (now - nym_refresh_interval_ / 2)); Schedule( server_publish_interval_, [storage]()-> void{ ServerLambda serverLambda([](const proto::ServerContract& server)-> void { App::Me().DHT().Insert(server); }); storage->MapServers(serverLambda); }, now); Schedule( server_refresh_interval_, [storage]()-> void{ ServerLambda serverLambda([](const proto::ServerContract& server)-> void { App::Me().DHT().GetServerContract(server.id()); }); storage->MapServers(serverLambda); }, (now - server_refresh_interval_ / 2)); Schedule( unit_publish_interval_, [storage]()-> void{ UnitLambda unitLambda([](const proto::UnitDefinition& unit)-> void { App::Me().DHT().Insert(unit); }); storage->MapUnitDefinitions(unitLambda); }, now); Schedule( unit_refresh_interval_, [storage]()-> void{ UnitLambda unitLambda([](const proto::UnitDefinition& unit)-> void { App::Me().DHT().GetUnitDefinition(unit.id()); }); storage->MapUnitDefinitions(unitLambda); }, (now - unit_refresh_interval_ / 2)); std::thread periodic(&App::Periodic, this); periodic.detach(); }
void Geometry::MoperatorGeneralBlochFill(Mat A, int b[3][2], int DimPeriod, double k[3], int ih){ int N[3]; for(int i=0; i<3; i++) N[i] = gN.x(i); double blochbc[3]; for(int i=0; i<3; i++) blochbc[i] = k[i]*N[i]*h[i]; int NC = 3, offset = ih*(Nxyzcr()+2); int ns, ne; double hh; int bc[3][2][3]; /* bc[x/y/z direction][lo/hi][Ex/Ey/Ez] */ dcomp val, magicnum, mucp[2], mulcp[2]; dcomp cidu_phase, cpidu_phase[2], cpidl_phase[2]; /* set up b ... */ for(int ic=0; ic<3; ic++) for(int j=0; j<2; j++) for(int k=0; k<3; k++) bc[ic][j][k] = b[ic][j]*( k==ic ? -1 :1); MatGetOwnershipRange(A, &ns, &ne); for (int itrue = ns; itrue < ne && itrue < 2*Nxyzc(); ++itrue) { Point p(itrue, Grid(N, Nc, 2)); p.project(3); int i = p.xyzcr(); int cp[2], icp[2], cidu, cpidu[2],cpidl[2], cid, cpid[2]; for(int j=0; j<2;j++){ cp[j] = (p.c()+1+j) % NC; icp[j] = i + (cp[j]-p.c() ) *Nxyz(); cpidu[j] = cyclic(p, 2-j, N); cpidl[j] = cyclic(p, 2-j, N); cpid[j] = cyclic(p, 2-j, N); cpidu_phase[j] = 1.0; cpidl_phase[j] = 1.0; } cidu = cyclic(p, 0, N); cid = cyclic(p, 0, N); cidu_phase = 1.0; for(int jr=0; jr<2; jr++) { /* column real/imag parts */ int jrd = (jr-p.r())*NC*Nxyz(); magicnum = (p.r()==jr)*1.0 + (p.r()<jr)*1.0*ComplexI - (p.r()>jr)*1.0* ComplexI; //===================================================================== Point prow(i, Grid(N,3,2)); prow.project(Nc); for(int ib=0; ib<2; ib++){ if(p.x(p.c()) == N[p.c()]-1){ int per = periodic(p.c(), DimPeriod ); cidu = per ? (1-N[p.c()])*cid : 0; cidu_phase = per? std::exp(ComplexI*blochbc[p.c()]) : bc[p.c()][1][cp[ib]]; } if(p.x(cp[ib]) == 0){ int per = periodic(cp[ib], DimPeriod ); cpidl[ib] = per ? (1-N[cp[ib]])*cpid[ib] : 0; cpidl_phase[ib] = per ? std::exp(-ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][0][cp[ib]]; } mucp[1-ib] = pmlval(icp[1-ib], N, Npml, h, LowerPML, 1); mulcp[1-ib] = pmlval(icp[1-ib]-cpidl[ib], N, Npml, h, LowerPML, 1); double c[4]; hh = h[p.c()]*h[cp[ib]]; val = mucp[1-ib] * magicnum /hh; c[1] = val.real(); val *= cidu_phase; c[0] = -val.real(); val = cpidl_phase[ib] * mulcp[1-ib] * magicnum/hh; c[3] = -val.real(); val *= -cidu_phase; c[2] = -val.real(); int dcol[4]; dcol[0] = cidu; dcol[1] = 0; dcol[2] = cidu-cpidl[ib]; dcol[3] = -cpidl[ib]; for(int w=0;w<4;w++){ Point pcol(icp[ib] + jrd+dcol[w], Grid(N,3,2) ); pcol.project(Nc); if(pcol.c()!=-1) MatSetValue(A, prow.xyzcr()+offset, pcol.xyzcr()+offset, c[w], ADD_VALUES); } if(p.x(cp[ib]) == N[cp[ib]]-1){ int per = periodic(cp[ib], DimPeriod ); cpidu[ib] = per ? (1-N[cp[ib]])*cpid[ib] : 0; cpidu_phase[ib] = per? std::exp(ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][1][p.c()]; } if(p.x(cp[ib]) == 0){ int per = periodic(cp[ib], DimPeriod ); cpidl[ib] = per ? (1-N[cp[ib]])*cpid[ib] : -cpidu[ib]; cpidl_phase[ib] = per? std::exp(-ComplexI*blochbc[cp[ib]]) : bc[cp[ib]][0][p.c()]; } hh = h[cp[ib]]*h[cp[ib]]; val = -(cpidu_phase[ib] * mucp[1-ib] * magicnum)/hh; c[0] = -val.real(); val = +( (mucp[1-ib] + mulcp[1-ib]) * magicnum)/hh;c[1] = -val.real(); val = -(cpidl_phase[ib] * mulcp[1-ib] * magicnum)/hh;c[2] = -val.real(); dcol[0] = cpidu[ib]; dcol[1] = 0; dcol[2] = -cpidl[ib]; for(int w=0;w<3;w++){ Point pcol(i + jrd+dcol[w], Grid(N,3,2) ); pcol.project(Nc); if(pcol.c()!=-1) MatSetValue(A, prow.xyzcr()+offset, pcol.xyzcr()+offset, c[w], ADD_VALUES); } } } } }
int main(void) { uint16_t major, minor, build; char *type; int i, res, count, count2; volatile uint32_t d; // insert a small delay so power supply can stabilize for (d=0; d<2500000; d++); #ifdef KEIL pixyInit(SRAM3_LOC, &LR0[0], sizeof(LR0)); #else pixyInit(); #endif #if 0 i = 0; char *foo; while(1) { foo = new (std::nothrow) char[128]; if (foo==NULL) { _DBG("full\n"); break; } else { _DBH32((int)foo); _DBG(" "); _DBH32(i); _DBG("\n"); } i++; } while(1); #endif // main init of hardware plus a version-dependent number for the parameters that will // force a format of parameter between version numbers. #ifndef LEGO rcs_init(); #endif cc_init(g_chirpUsb); ser_init(); exec_init(g_chirpUsb); #if 0 exec_addProg(&g_progBlobs); ptLoadParams(); exec_addProg(&g_progPt); exec_addProg(&g_progVideo, true); #if 0 cam_setMode(CAM_MODE1); while(1) periodic(); #endif #endif #if 1 // load programs exec_addProg(&g_progBlobs); #ifndef LEGO // need to call this to get the pan/tilt parameters to display. // We can make some properties modal, meaning they are only diaplayed when the program is running. // We might want to do this here, but this is good for now. ptLoadParams(); exec_addProg(&g_progPt); #endif #if 0 chaseLoadParams(); exec_addProg(&g_progChase); #endif exec_addProg(&g_progVideo, true); #if 1 // this code formats if the version has changed for (i=0, count=0, count2=0; i<25; i++) { res = prm_get("fwver", &major, &minor, &build, END); if (res>=0 && major==FW_MAJOR_VER && minor==FW_MINOR_VER && build==FW_BUILD_VER) count++; res = prm_get("fwtype", &type, END); if (res>=0 && strcmp(type, FW_TYPE)==0) count2++; } if (count==0 || count2==0) prm_format(); #endif // check version prm_add("fwver", PRM_FLAG_INTERNAL, "", UINT16(FW_MAJOR_VER), UINT16(FW_MINOR_VER), UINT16(FW_BUILD_VER), END); prm_add("fwtype", PRM_FLAG_INTERNAL, "", STRING(FW_TYPE), END); exec_loop(); #endif #if 0 #define DELAY 1000000 rcs_setFreq(100); rcs_setLimits(0, -200, 200); rcs_setLimits(1, -200, 200); while(1) { rcs_setPos(0, 0); delayus(DELAY); rcs_setPos(0, 500); delayus(DELAY); rcs_setPos(0, 1000); delayus(DELAY); rcs_setPos(1, 0); delayus(DELAY); rcs_setPos(1, 500); delayus(DELAY); rcs_setPos(1, 1000); delayus(DELAY); } #endif #if 0 while(1) { g_chirpUsb->service(); handleButton(); } #endif }
void bx_pit_c::write(Bit32u address, Bit32u dvalue, unsigned io_len) { #else UNUSED(this_ptr); #endif // !BX_USE_PIT_SMF Bit8u value; Bit64u my_time_usec = bx_virt_timer.time_usec(); Bit64u time_passed = my_time_usec-BX_PIT_THIS s.last_usec; Bit32u time_passed32 = (Bit32u)time_passed; if(time_passed32) { periodic(time_passed32); } BX_PIT_THIS s.last_usec = BX_PIT_THIS s.last_usec + time_passed; value = (Bit8u) dvalue; BX_DEBUG(("write to port 0x%04x, value = 0x%02x", address, value)); switch (address) { case 0x40: /* timer 0: write count register */ BX_PIT_THIS s.timer.write(0, value); break; case 0x41: /* timer 1: write count register */ BX_PIT_THIS s.timer.write(1, value); break; case 0x42: /* timer 2: write count register */ BX_PIT_THIS s.timer.write(2, value); break; case 0x43: /* timer 0-2 mode control */ BX_PIT_THIS s.timer.write(3, value); break; case 0x61: BX_PIT_THIS s.speaker_data_on = (value >> 1) & 0x01; if (BX_PIT_THIS s.speaker_data_on) { DEV_speaker_beep_on((float)(1193180.0 / BX_PIT_THIS get_timer(2))); } else { DEV_speaker_beep_off(); } /* ??? only on AT+ */ BX_PIT_THIS s.timer.set_GATE(2, value & 0x01); break; default: BX_PANIC(("unsupported io write to port 0x%04x = 0x%02x", address, value)); } if (time_passed || (BX_PIT_THIS s.last_next_event_time != BX_PIT_THIS s.timer.get_next_event_time())) { BX_DEBUG(("RESETting timer")); bx_virt_timer.deactivate_timer(BX_PIT_THIS s.timer_handle[0]); BX_DEBUG(("deactivated timer")); if(BX_PIT_THIS s.timer.get_next_event_time()) { bx_virt_timer.activate_timer(BX_PIT_THIS s.timer_handle[0], (Bit32u)BX_MAX(1,TICKS_TO_USEC(BX_PIT_THIS s.timer.get_next_event_time())), 0); BX_DEBUG(("activated timer")); } BX_PIT_THIS s.last_next_event_time = BX_PIT_THIS s.timer.get_next_event_time(); } BX_DEBUG(("s.last_usec="FMT_LL"d", BX_PIT_THIS s.last_usec)); BX_DEBUG(("s.timer_id=%d", BX_PIT_THIS s.timer_handle[0])); BX_DEBUG(("s.timer.get_next_event_time=%x", BX_PIT_THIS s.timer.get_next_event_time())); BX_DEBUG(("s.last_next_event_time=%d", BX_PIT_THIS s.last_next_event_time)); }
void system::distribute_data(const bool FLUID, const bool GRADS, const bool NGB) { distribute_data_flag = true; ptcl_local.resize(local_n); std::vector<vec3> ptcl_pos(local_n); // compute integer coordinates for each position // for (int i = 0; i < (int)local_n; i++) { ptcl_local[i].local_id = i; ptcl_local[i].orig_pos = periodic(ptcl_local[i].orig_pos); ptcl_pos[i] = ptcl_local[i].orig_pos; } // determine domain decomposition // std::vector<vec3> sample_pos; determine_sampling_freq(); collect_sample_data(sample_pos, ptcl_pos); DistributeNew<real, vec3, boundary> distribute(nproc, global_domain); if (myproc == 0) { // distribute_glb.determine_division(sample_pos); #if 1 distribute.determine_division(sample_pos, nproc*32); #else distribute.determine_division(sample_pos, nproc*8); #endif } myMPI::Bcast(distribute.tiles, 0, nproc); myMPI::Bcast(distribute.procs, 0, nproc); compute_proc_domain(distribute.tiles, distribute.procs); if (FLUID && GRADS) for (int i = 0; i < (int)local_n; i++) Wrec_local[i].pos.x = divBi[i]; int iloc = 0; std::vector<Particle> ptcl_send[NMAXPROC]; std::vector<Particle> ptcl_recv[NMAXPROC]; std::vector<ParticleFluidStruct> fluid_send[NMAXPROC]; std::vector<ParticleFluidStruct> fluid_recv[NMAXPROC]; std::vector<ParticleFluidStructLite> fluidlite_send[NMAXPROC]; std::vector<ParticleFluidStructLite> fluidlite_recv[NMAXPROC]; #if 0 std::vector<int> ngb_send[NMAXPROC]; std::vector<int> ngb_recv[NMAXPROC]; #endif std::vector<int> remote_tiles; int nremove = 0; for (int i = 0; i < (int)local_n; i++) { remote_tiles.clear(); proc_tree.root.walk_boundary(boundary(ptcl_pos[i]), remote_tiles, global_domain_size); assert(remote_tiles.size() > 0); const int proc = proc_procs[remote_tiles[0]]; assert(proc >= 0); assert(proc < nproc); if (proc == myproc && !ptcl_local[i].is_remove()) { std::swap(ptcl_local[i], ptcl_local[iloc]); std::swap(ptcl_pos [i], ptcl_pos [iloc]); if (FLUID) { std::swap( U_local[i], U_local[iloc]); std::swap( dU_local[i], dU_local[iloc]); if (GRADS) std::swap(Wrec_local[i], Wrec_local[iloc]); } iloc++; } else if (!ptcl_local[i].is_remove()) { if (FLUID && GRADS) fluid_send[proc].push_back(ParticleFluidStruct(ptcl_local[i], U_local[i], dU_local[i], Wrec_local[i])); else if (FLUID) fluidlite_send[proc].push_back(ParticleFluidStructLite(ptcl_local[i], U_local[i], dU_local[i])); else ptcl_send[proc].push_back(ptcl_local[i]); } else nremove++; } #if 0 if (FLUID && GRADS) myMPI::all2all(fluid_send, fluid_recv, myproc, nproc, mpi_debug_flag); else if (FLUID ) myMPI::all2all(fluidlite_send, fluidlite_recv, myproc, nproc, mpi_debug_flag); else myMPI::all2all(ptcl_send, ptcl_recv, myproc, nproc, mpi_debug_flag); #else { static int nsend[NMAXPROC], nrecv[NMAXPROC]; if (FLUID && GRADS) myMPI::all2all<true>(fluid_send, fluid_recv, myproc, nproc, 1, nsend, nrecv); else if (FLUID ) myMPI::all2all<true>(fluidlite_send, fluidlite_recv, myproc, nproc, 1, nsend, nrecv); else myMPI::all2all<true>(ptcl_send, ptcl_recv, myproc, nproc, 1, nsend, nrecv); } #endif int nrecv = 0; if (FLUID && GRADS) for (int p = 0; p < nproc; p++) nrecv += fluid_recv[p].size(); else if (FLUID) for (int p = 0; p < nproc; p++) nrecv += fluidlite_recv[p].size(); else for (int p = 0; p < nproc; p++) nrecv += ptcl_recv[p].size(); { const int nloc = iloc + nrecv; ptcl_local.resize(nloc); fit_vec(ptcl_local); U_local .resize(nloc); fit_vec(U_local); dU_local .resize(nloc); fit_vec(dU_local); Wrec_local.resize(nloc); fit_vec(Wrec_local); divBi .resize(nloc); fit_vec(divBi); Wextra_local.resize(nloc); fit_vec(Wextra_local); } for (int p = 0; p < nproc; p++) for (size_t q = 0; q < (FLUID ? (GRADS ? fluid_recv[p].size() : fluidlite_recv[p].size()) : ptcl_recv[p].size()); q++) { assert(p != myproc); if (FLUID && GRADS) { ptcl_local[iloc] = fluid_recv[p][q].p; U_local [iloc] = fluid_recv[p][q].U; dU_local [iloc] = fluid_recv[p][q].dU; Wrec_local[iloc] = fluid_recv[p][q].Wrec; } else if (FLUID) { ptcl_local[iloc] = fluidlite_recv[p][q].p; U_local [iloc] = fluidlite_recv[p][q].U; dU_local [iloc] = fluidlite_recv[p][q].dU; } else ptcl_local[iloc] = ptcl_recv[p][q]; assert(!ptcl_local[iloc].is_remove()); iloc++; } local_n = iloc; assert(iloc = (int)ptcl_local.size()); if (FLUID && GRADS) for (int i = 0; i < (int)local_n; i++) { divBi[i] = Wrec_local[i].pos.x; Wrec_local[i].pos.x = ptcl_local[i].pos.x; } unsigned long long nglob, nloc = local_n; unsigned long long nvirt_glob; virtual_n = nremove; MPI_Allreduce(&nloc, &nglob, 1, MPI_UNSIGNED_LONG_LONG, MPI_SUM, MPI_COMM_WORLD); MPI_Allreduce(&virtual_n, &nvirt_glob, 1, MPI_UNSIGNED_LONG_LONG, MPI_SUM, MPI_COMM_WORLD); unsigned long long local_n_min, local_n_max, local_n_mean; MPI_Allreduce(&local_n, &local_n_min, 1, MPI_UNSIGNED_LONG_LONG, MPI_MIN, MPI_COMM_WORLD); MPI_Allreduce(&local_n, &local_n_max, 1, MPI_UNSIGNED_LONG_LONG, MPI_MAX, MPI_COMM_WORLD); MPI_Allreduce(&local_n, &local_n_mean, 1, MPI_UNSIGNED_LONG_LONG, MPI_SUM, MPI_COMM_WORLD); if (myproc == 0) { fprintf(stderr, "local_n= [min: %llu max: %llu ; mean: %llu ] global_n= %llu nglob= %llu remove_n_glob= %llu \n", local_n_min, local_n_max, local_n_mean/nproc, global_n, nglob, nvirt_glob); } MPI_Barrier(MPI_COMM_WORLD); assert(nglob == global_n - nvirt_glob); global_n = nglob; virtual_n = 0; sort_local_data(); // build local tree // global_domain_size = global_domain.hsize() * 2.0; local_tree.clear(); local_tree.set_domain( boundary( global_domain.centre() - global_domain.hsize()*1.5, global_domain.centre() + global_domain.hsize()*1.5)); std::vector<Octree::Particle> tree_ptcl(local_n); for (int i = 0; i < (int)local_n; i++) { assert(!ptcl_local[i].is_remove()); tree_ptcl[i] = Octree::Particle(ptcl_local[i].orig_pos, i); } local_tree.insert(&tree_ptcl[0], local_n, 0, local_n); local_tree.get_leaves(); local_tree.root.inner_boundary(); if (NGB) { if (myproc == 0) fprintf(stderr, "---buidling mesh---\n"); const double t10 = mytimer::get_wtime(); clear_mesh(false); const double t15 = mytimer::get_wtime(); build_mesh_global(); double dt_mesh = mytimer::get_wtime() - t15; double volume_loc = 0.0; { std::vector<TREAL> v(local_n); for (int i = 0; i < (int)local_n; i++) { v[i] = cell_local[i].Volume; ptcl_local[i].volume_new = v[i]; ptcl_local[i].local_id = i; } std::sort(v.begin(), v.end()); // sort volumes from low to high, to avoid roundoff errors for (int i = 0; i < (int)local_n; i++) volume_loc += v[i]; } extract_ngb_from_mesh(); clear_mesh(true); double dt = mytimer::get_wtime() - t10; double volume_glob = 0.0; double dt_max = 0.0; double dt_mesh_max = 0.0; MPI_Allreduce(&volume_loc, &volume_glob, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD); MPI_Allreduce(&dt, &dt_max, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD); MPI_Allreduce(&dt_mesh, &dt_mesh_max, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD); const double volume_exact = global_domain_size.x*global_domain_size.y*global_domain_size.z; if (myproc == 0) { fprintf(stderr, " distribute::build_mesh:[ %g (all %g ) sec :: %g cells/s/proc/thread ]\n", dt_mesh_max, dt_max, global_n/nproc/dt_mesh_max); fprintf(stderr, " computed_volume= %g exact_volume= %g diff= %g [ %g ] \n", volume_glob, volume_exact, volume_glob - volume_exact, (volume_glob - volume_exact)/volume_exact); } } }
/*! wrapping() holds whether it is possible to step the value from the highest value to the lowest value and vice versa. \sa setWrapping(), QwtDoubleRange::setPeriodic() \note The meaning of wrapping is like the wrapping property of QSpinBox, but not like it is used in QDial. */ bool QwtDial::wrapping() const { return periodic(); }
int main (int argc, char **argv) { struct timeval tv; #ifdef HAVE_LIBKVM if (kvm_init()) can_use_kvm = 1; #endif #ifdef DEBUG if (!(debug_file = fopen("debug", "w"))) { printf("file debug open error\n"); exit(0); } #endif get_boot_time(); get_rows_cols(&screen_rows, &screen_cols); buf_size = screen_cols + screen_cols/2; line_buf = malloc(buf_size); if (!line_buf) errx(1, "Cannot allocate memory for buffer."); curses_init(); current = &users_list; users_init(); procwin_init(); subwin_init(); menu_init(); signal(SIGINT, int_handler); signal(SIGWINCH, winch_handler); // signal(SIGSEGV, segv_handler); print_help(); update_load(); current->redraw(); wnoutrefresh(main_win); wnoutrefresh(info_win.wd); wnoutrefresh(help_win.wd); doupdate(); tv.tv_sec = TIMEOUT; tv.tv_usec = 0; for(;;) { /* main loop */ #ifndef RETURN_TV_IN_SELECT struct timeval before; struct timeval after; #endif fd_set rfds; int retval; FD_ZERO(&rfds); FD_SET(STDIN_FILENO,&rfds); #ifdef RETURN_TV_IN_SELECT retval = select(1, &rfds, 0, 0, &tv); if(retval > 0) { int key = read_key(); key_action(key); } if (!tv.tv_sec && !tv.tv_usec){ ticks++; periodic(); tv.tv_sec = TIMEOUT; } #else gettimeofday(&before, 0); retval = select(1, &rfds, 0, 0, &tv); gettimeofday(&after, 0); tv.tv_sec -= (after.tv_sec - before.tv_sec); if(retval > 0) { int key = read_key(); key_action(key); } if(tv.tv_sec <= 0) { ticks++; periodic(); tv.tv_sec = TIMEOUT; } #endif if (size_changed) resize(); } }
void kern_only_test() { // for a simple second test // let's just output in a csv our kernels over 2D surfaces CovMat<2> eye; eye << 1, 0, 0, 1; FeatVec<2> mean; mean << 2, 2; const std::vector<double> std_params = {1.0, 1.0, 1.0}; const std::vector<double> lin_params = {-2.0, 1.0, 1.0}; auto se_kfn = se_generator<2>(std_params); auto per_kfn = per_generator<2>(std_params); auto lin_kfn = lin_generator<2>(lin_params); auto rq_kfn = rq_generator<2>(std_params); auto se_x_per = [se_kfn, per_kfn] (const FeatVec<2>& a, const FeatVec<2>&b, const CovMat<2>& covar) { return se_kfn(a, b, covar) * per_kfn(a, b, covar); }; auto se_x_lin = [se_kfn, lin_kfn] (const FeatVec<2>& a, const FeatVec<2>&b, const CovMat<2>& covar) { return se_kfn(a, b, covar) * lin_kfn(a, b, covar); }; auto per_x_lin = [per_kfn, lin_kfn] (const FeatVec<2>& a, const FeatVec<2>&b, const CovMat<2>& covar) { return per_kfn(a, b, covar) * lin_kfn(a, b, covar); }; auto per_p_lin = [per_kfn, lin_kfn] (const FeatVec<2>& a, const FeatVec<2>&b, const CovMat<2>& covar) { return per_kfn(a, b, covar) + lin_kfn(a, b, covar); }; auto se_p_per = [se_kfn, per_kfn] (const FeatVec<2>& a, const FeatVec<2>&b, const CovMat<2>& covar) { return se_kfn(a, b, covar) + per_kfn(a, b, covar); }; Kernel<2> squared_exp(se_kfn, mean, eye); Kernel<2> periodic(per_kfn, mean, eye); Kernel<2> liniar(lin_kfn, mean, eye); Kernel<2> rational_quad(rq_kfn, mean, eye); Kernel<2> se_times_per(se_x_per, mean, eye); Kernel<2> se_times_lin(se_x_lin, mean, eye); Kernel<2> per_times_lin(per_x_lin, mean, eye); Kernel<2> per_plus_lin(per_p_lin, mean, eye); Kernel<2> se_plus_per(se_p_per, mean, eye); std::ofstream se_dump("../../data-plots/se.csv"); std::ofstream per_dump("../../data-plots/per.csv"); std::ofstream lin_dump("../../data-plots/lin.csv"); std::ofstream rq_dump("../../data-plots/rq.csv"); std::ofstream se_x_per_dump("../../data-plots/se_x_per.csv"); std::ofstream se_x_lin_dump("../../data-plots/se_x_lin.csv"); std::ofstream per_x_lin_dump("../../data-plots/per_x_lin.csv"); std::ofstream per_p_lin_dump("../../data-plots/per_p_lin.csv"); std::ofstream se_p_per_dump("../../data-plots/se_p_per.csv"); test_2d_kernel(squared_exp, se_dump, 100, 4); test_2d_kernel(periodic, per_dump, 100, 4); test_2d_kernel(liniar, lin_dump, 100, 4); test_2d_kernel(rational_quad, rq_dump, 100, 4); test_2d_kernel(se_times_per, se_x_per_dump, 100, 4); test_2d_kernel(se_times_lin, se_x_lin_dump, 100, 4); test_2d_kernel(per_times_lin, per_x_lin_dump, 100, 4); test_2d_kernel(per_plus_lin, per_p_lin_dump, 100, 4); test_2d_kernel(se_plus_per, se_p_per_dump, 100, 4); }
void system::read_binary(const char *filename, const int n_files) { #if 1 assert(n_files == 1); vec3 rmin, rmax; if (myproc == 0) { FILE *fin; if (!(fin = fopen(filename, "r"))) { std::cerr << "Cannot open file " << filename << std::endl; exit(-1); } std::cerr << "proc= " << myproc << " read snapshot: " << filename << std::endl; int ival; float fval; #define fload(x) { myfread(&fval, sizeof(float), 1, fin); x = fval; } #define iload(x) { myfread(&ival, sizeof(int), 1, fin); x = ival;} float ftmp; int itmp, np0, npx, npy, npz; iload(itmp); // 20*4 assert(itmp == 20*4); iload(itmp); // myid iload(np0); iload(npx); union { unsigned long long uint_long; unsigned int uint[2]; } data; iload(data.uint[0]); iload(data.uint[1]); scheduler.tsysU = data.uint_long; float courant_No; int nglob, nloc, ndim; iload(nglob); iload(nloc); iload(ndim); assert(ndim == 3); fload(t_global); fload(dt_global); iload(iteration); fload(courant_No); fload(gamma_gas); int periodic_on; iload(periodic_on); assert(periodic_on == -1); fload(rmin.x); fload(rmin.y); fload(rmin.z); fload(rmax.x); fload(rmax.y); fload(rmax.z); iload(itmp); // 20*4 assert(itmp == 20*4); ptcl_local.resize(nglob); U_local.resize(nglob); dU_local.resize(nglob); fprintf(stderr, "np =%d nglob= %d \n", np0, nglob); int pc = 0; for (int pr = 0; pr < np0; pr++) { fprintf(stderr, " p= %d out of %d; nloc= %d\n", pr, np0, nloc); for (int i = 0; i < nloc; i++) { Particle p; p.tend = t_global; p.rung = 0.0; p.new_dt = 0.0; p.local_id = i; Fluid W(0.0); iload(ival); assert(ival == 26*4); iload(ival); p.idx = ival; fload(p.pos.x); fload(p.pos.y); fload(p.pos.z); p.pos = periodic(p.pos); assert(rmin.x <= p.pos.x); assert(rmax.x >= p.pos.x); assert(rmin.y <= p.pos.y); assert(rmax.y >= p.pos.y); assert(rmin.z <= p.pos.z); assert(rmax.z >= p.pos.z); p.orig_pos = p.pos; p.pot = 0; fload(p.vel.x); fload(p.vel.y); fload(p.vel.z); p.orig_vel = p.vel; fload(W[Fluid::DENS]); fload(W[Fluid::ETHM]); fload(ftmp); // compute_pressure(m.dens, m.ethm)); fload(p.rmax); //dump( (sqr(m.B.x ) + sqr(m.B.y ) + sqr(m.B.z ))*0.5f); iload(p.boundary); // fload(ftmp); //dump(sqrt(sqr(m.vel.x) + sqr(m.vel.y) + sqr(m.vel.z))); fload(W[Fluid::VELX]); fload(W[Fluid::VELY]); fload(W[Fluid::VELZ]); fload(W[Fluid::BX]); fload(W[Fluid::BY]); fload(W[Fluid::BZ]); float h; fload(h); fload(p.volume); p.volume_new = p.volume; fload(W[Fluid::PSI]); fload(ftmp); //L*divB_i[i]); fload(W[Fluid::ENTR]); fload(ftmp); // Jx fload(ftmp); // Jy fload(ftmp); // Jz iload(ival); assert(ival == 26*4); p.tlast = t_global; ptcl_local[pc] = p; U_local [pc] = W; dU_local [pc] = 0.0; dU_local [pc] = 0.0; pc++; } fprintf(stderr, "p= %d np0= %d size= %d %d\n", pr, np0, (int)U_local.size(), (int)ptcl_local.size()); if (!(pr < np0-1)) break; iload(itmp); // 20*4 assert(itmp == 20*4); iload(itmp); // myid iload(np0); iload(npx); iload(npy); iload(npz); int nglob1; iload(nglob1); if (nglob != nglob1) { fprintf(stderr, "np; npx, npy, npz = %d; %d %d %d \n", np0, npx, npy, npz); fprintf(stderr, "nglob= %d nglob1= %d\n", nglob, nglob1); } assert(nglob == nglob1); iload(nloc); iload(ndim); fload(t_global); fload(dt_global); iload(iteration); fload(courant_No); fload(gamma_gas); iload(periodic_on); fload(rmin.x); fload(rmin.y); fload(rmin.z); fload(rmax.x); fload(rmax.y); fload(rmax.z); iload(itmp); // 20*4 } assert(pc == nglob); assert(nglob == (int)U_local.size()); fclose(fin); local_n = U_local.size(); } global_n = U_local.size(); local_n = global_n; MPI_Bcast(&global_n, 1, MPI_UNSIGNED_LONG_LONG, 0, MPI_COMM_WORLD); MPI_Bcast(&iteration, 1, MPI_INT, 0, MPI_COMM_WORLD); double dt_glob = dt_global; double t_glob = t_global; MPI_Bcast(& t_glob, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD); MPI_Bcast(&dt_glob, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD); MPI_Bcast(&scheduler.tsysU, 1, MPI_UNSIGNED_LONG_LONG, 0, MPI_COMM_WORLD); dt_global = dt_glob; t_global = t_glob; scheduler.set_tsys(t_global); assert(t_global == scheduler.get_tsys()); // scheduler.tsysU = (unsigned long long)(t_global / scheduler.dt_tick); scheduler.min_rung = 0; dt_global = 0.0f; distribute_data(true, false, true); #if 1 fit_vec(ptcl_local); fit_vec(U_local); fit_vec(dU_local); fit_vec(Wrec_local); #endif all_active = true; MPI_Barrier(MPI_COMM_WORLD); for (int i = 0; i < (int)local_n; i++) { ptcl_local[i].tlast = t_global; // ptcl_local[i].volume = cell_local[i].Volume; Wrec_local[i] = Fluid_rec(U_local[i]); U_local[i] = U_local[i].to_conservative(ptcl_local[i].volume); dU_local[i] = 0.0; } MPI_Barrier(MPI_COMM_WORLD); if (myproc == 0) fprintf(stderr , " pvel ... \n"); get_active_ptcl(true); MPI_Barrier(MPI_COMM_WORLD); if (myproc == 0) fprintf(stderr , " pvel ... \n"); cell_list.swap(cell_local); ptcl_import.swap(ptcl_local); U_import.swap(U_local); site_active_list.swap(active_ptcl); compute_pvel(); compute_timesteps(true); cell_list.swap(cell_local); ptcl_import.swap(ptcl_local); U_import.swap(U_local); site_active_list.swap(active_ptcl); for (int i = 0; i < (int)local_n; i++) { ptcl_local[i].rung += 1; ptcl_local[i].tend = ptcl_local[i].tlast + scheduler.get_dt(ptcl_local[i].rung); ptcl_local[i].orig_vel = ptcl_local[i].vel; ptcl_local[i].unset_active(); } all_active = true; scheduler.flush_list(); boundary_n = 0; for (int i = 0; i < (int)local_n; i++) { scheduler.push_particle(i, (int)ptcl_local[i].rung); if (ptcl_local[i].is_boundary()) boundary_n++; } unsigned long long boundary_glb; MPI_Allreduce(&boundary_n, &boundary_glb, 1, MPI_UNSIGNED_LONG_LONG, MPI_SUM, MPI_COMM_WORLD); if (myproc == 0) fprintf(stderr, "boundary_glb= %lld\n", boundary_glb); clear_mesh(true); MPI_Barrier(MPI_COMM_WORLD); if (myproc == 0) fprintf(stderr, " proc= %d: complete read_binary \n", myproc); #endif }
/* This function computes the local velocity dispersion * of each particle (among particles of the same type) */ void veldisp(void) { double vsum[3], v2sum[3]; double h, hinv, hinv3; double rho, wk; double dx, dy, dz, r, r2, u; int i,j,k,ii,n,count; float *r2list; int *ngblist; /* only active particles */ for(i=IndFirstUpdate,count=0; count<NumForceUpdate; i=P[i].ForceFlag, count++) { if(P[i].Type>0) { rho= vsum[0] = vsum[1] = vsum[2] = v2sum[0] = v2sum[1] = v2sum[2] = 0; P[i].HsmlVelDisp= sqrt(ngb_treefind(P[i].PosPred, All.DesNumNgb, 1.1*P[i].HsmlVelDisp, P[i].Type, &ngblist, &r2list)); h = P[i].HsmlVelDisp; hinv = 1.0/h; hinv3 = hinv*hinv*hinv; for(n=0; n<All.DesNumNgb; n++) { j = ngblist[n]+1; dx = P[i].PosPred[0] - P[j].PosPred[0]; dy = P[i].PosPred[1] - P[j].PosPred[1]; dz = P[i].PosPred[2] - P[j].PosPred[2]; #ifdef PERIODIC dx= periodic(dx); dy= periodic(dy); dz= periodic(dz); #endif r2 = dx*dx + dy*dy + dz*dz; r = sqrt(r2); if(r<h) { u = r*hinv; ii = (int)(u*KERNEL_TABLE); wk =hinv3*( Kernel[ii] + (Kernel[ii+1]-Kernel[ii])*(u-KernelRad[ii])*KERNEL_TABLE); rho += P[j].Mass * wk; } for(k=0; k<3; k++) { vsum[k] += P[j].VelPred[k]; v2sum[k] += P[j].VelPred[k]*P[j].VelPred[k]; } } P[i].DensVelDisp = rho; P[i].VelDisp = 0; for(k=0; k<3; k++) { vsum[k] /= All.DesNumNgb; v2sum[k]/= All.DesNumNgb; P[i].VelDisp += v2sum[k] - vsum[k]*vsum[k]; } if(P[i].VelDisp > 0) P[i].VelDisp= sqrt(P[i].VelDisp); else P[i].VelDisp= 0; } } }
bool ButtonMachine::selectProgram(uint8_t progs, uint8_t *selectedProg) { uint32_t bt; if (progs<=1) return 0; while(1) { bt = button(); periodic(); switch(m_goto) { case 0: // wait for nothing setTimer(&m_timer); m_goto = 1; setLED(); break; case 1: // wait for button down if (bt) { setTimer(&m_timer); m_index=0; setLED(); m_goto = 2; } else if (getTimer(m_timer)>BT_PROG_TIMEOUT) { m_index = *selectedProg; flashLED(4); reset(); return false; } break; case 2: // cycle through choices, wait for button up if (!bt) { *selectedProg = m_index; // save m_index flashLED(4); reset(); // resets m_index return true; } else if (getTimer(m_timer)>BT_INDEX_CYCLE_TIMEOUT) { setTimer(&m_timer); m_index++; if (m_index==progs) m_index = 0; setLED(); } break; default: reset(); } } }
void DistanceToAtom::compute(const QVector<QVector3D> &pointsOriginal, float cutoff) { if(pointsOriginal.size() == 0) { qDebug() << "DistanceToAtom::compute WARNING: input vector is empty."; return; } QElapsedTimer timer; timer.start(); float min = 1e90; float max = -1e90; for(const QVector3D &point : pointsOriginal) { min = std::min(min, point[0]); min = std::min(min, point[1]); min = std::min(min, point[2]); max = std::max(max, point[0]); max = std::max(max, point[1]); max = std::max(max, point[2]); } max += 1e-5; const float systemSize = max - min; // Now translate all points QVector<QVector3D> points = pointsOriginal; for(QVector3D &point : points) { point[0] -= min; point[1] -= min; point[2] -= min; } float cellSize; CellList cellList = buildCellList(points, systemSize, cutoff, cellSize); const int numCells = cellList.size(); // Each index should be identical m_values.clear(); m_values.resize(m_numberOfRandomVectors); m_randomNumbers.resize(3*m_numberOfRandomVectors); for(int i=0; i<3*m_numberOfRandomVectors; i++) { m_randomNumbers[i] = floatRandom(0, systemSize); } const float oneOverCellSize = 1.0/cellSize; #pragma omp parallel for num_threads(8) for(int i=0; i<m_numberOfRandomVectors; i++) { const float x = m_randomNumbers[3*i+0]; const float y = m_randomNumbers[3*i+1]; const float z = m_randomNumbers[3*i+2]; const int cx = x * oneOverCellSize; const int cy = y * oneOverCellSize; const int cz = z * oneOverCellSize; float minimumDistanceSquared = 1e10; const float minimumDistanceSquared0 = minimumDistanceSquared; // Loop through all 27 cells with size=cutoff for(int dx=-1; dx<=1; dx++) { for(int dy=-1; dy<=1; dy++) { for(int dz=-1; dz<=1; dz++) { const vector<QVector3D> &pointsInCell = cellList[periodic(cx+dx, numCells)][periodic(cy+dy, numCells)][periodic(cz+dz, numCells)]; const int numberOfPointsInCell = pointsInCell.size(); for(int j=0; j<numberOfPointsInCell; j++) { // const QVector3D &point = points[pointIndex]; const QVector3D &point = pointsInCell[j]; float dx = x - point[0]; float dy = y - point[1]; float dz = z - point[2]; if(dx < -0.5*systemSize) dx += systemSize; else if(dx > 0.5*systemSize) dx -= systemSize; if(dy < -0.5*systemSize) dy += systemSize; else if(dy > 0.5*systemSize) dy -= systemSize; if(dz < -0.5*systemSize) dz += systemSize; else if(dz > 0.5*systemSize) dz -= systemSize; const float distanceSquared = dx*dx + dy*dy + dz*dz; if(distanceSquared < minimumDistanceSquared) minimumDistanceSquared = distanceSquared; } } } } if(minimumDistanceSquared == minimumDistanceSquared0) { minimumDistanceSquared = -1; } m_values[i] = float(minimumDistanceSquared); } m_randomNumbers.clear(); points.clear(); // qDebug() << "DTO finished after " << timer.elapsed() << " ms."; m_isValid = true; // if(pointsOriginal.size() == 0) { // qDebug() << "DistanceToAtom::compute WARNING: input vector is empty."; // return; // } // float min = 1e90; // float max = -1e90; // for(const QVector3D &point : pointsOriginal) { // min = std::min(min, point[0]); // min = std::min(min, point[1]); // min = std::min(min, point[2]); // max = std::max(max, point[0]); // max = std::max(max, point[1]); // max = std::max(max, point[2]); // } // max += 1e-5; // const float systemSize = max - min; // // Now translate all points // QVector<QVector3D> points = pointsOriginal; // for(QVector3D &point : points) { // point[0] -= min; // point[1] -= min; // point[2] -= min; // } // float cellSize; // CellList cellList = buildCellList(points, systemSize, cutoff, cellSize); // const int numCells = cellList.size(); // Each index should be identical // const float voxelSize = systemSize / m_size; // for(int i=0; i<m_size; i++) { // for(int j=0; j<m_size; j++) { // for(int k=0; k<m_size; k++) { // const QVector3D voxelCenter((i+0.5)*voxelSize, (j+0.5)*voxelSize, (k+0.5)*voxelSize); // float minimumDistanceSquared0 = 1e10; // float minimumDistanceSquared = 1e10; // // Find the cell list where this position belongs and loop through all cells around // const int cx = voxelCenter[0] / cellSize; // const int cy = voxelCenter[1] / cellSize; // const int cz = voxelCenter[2] / cellSize; // // Loop through all 27 cells with size=cutoff // for(int dx=-1; dx<=1; dx++) { // for(int dy=-1; dy<=1; dy++) { // for(int dz=-1; dz<=1; dz++) { // const vector<int> &pointsInCell = cellList[periodic(cx+dx, numCells)][periodic(cy+dy, numCells)][periodic(cz+dz, numCells)]; // for(const int &pointIndex : pointsInCell) { // const QVector3D &point = points[pointIndex]; // const float distanceSquared = periodicDistanceSquared(point, voxelCenter, systemSize); // minimumDistanceSquared = std::min(minimumDistanceSquared, distanceSquared); // } // } // } // } // if(minimumDistanceSquared == minimumDistanceSquared0) { // minimumDistanceSquared = -1; // } // setValue(i,j,k,float(minimumDistanceSquared)); // } // } // } // m_isValid = true; }