int main(int argc, string argv[]) { string prog, coords, itags[MaxBodyFields], otags[MaxBodyFields]; stream xstr, ostr; bodyptr btab = NULL, bp; int nbody; real tnow; vector cmpos, cmvel, cmacc; initparam(argv, defv); exprs[0] = getparam("weight"); prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char))); buildmap(prog, names, exprs, types, NULL, Precision, NDIM, TRUE); xstr = execmap(prog); if (get_tag_ok(xstr, "History")) skip_item(xstr); get_history(xstr); ostr = stropen(getparam("out"), "w"); put_history(ostr); coords = getparam("coords"); new_field(&WeightField, RealType, "Weight"); new_field(&WeightField + 1, NULL, NULL); while (get_snap(xstr, &btab, &nbody, &tnow, itags, TRUE, NULL)) { if (scanopt(coords, PosTag) && set_member(itags, PosTag)) { snapcmpos(cmpos, btab, nbody, WeightField.offset); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { SUBV(Pos(bp), Pos(bp), cmpos); } eprintf("[%s: centroid position: %f,%f,%f]\n", getprog(), cmpos[0], cmpos[1], cmpos[2]); } if (scanopt(coords, VelTag) && set_member(itags, VelTag)) { snapcmvel(cmvel, btab, nbody, WeightField.offset); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { SUBV(Vel(bp), Vel(bp), cmvel); } eprintf("[%s: centroid velocity: %f,%f,%f]\n", getprog(), cmvel[0], cmvel[1], cmvel[2]); } if (scanopt(coords, AccTag) && set_member(itags, AccTag)) { snapcmacc(cmacc, btab, nbody, WeightField.offset); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { SUBV(Acc(bp), Acc(bp), cmacc); } eprintf("[%s: cen. acceleration: %f,%f,%f]\n", getprog(), cmacc[0], cmacc[1], cmacc[2]); } del_tag(otags, itags, "Weight"); put_snap(ostr, &btab, &nbody, &tnow, otags); } strclose(ostr); if (unlink(prog) != 0) error("%s: can't unlink %s\n", getprog(), prog); return (0); }
local void hqmforces(bodyptr btab, int nbody, real M, real a, real b, real tol) { bodyptr bp; double r, mr3i, params[4], phi0, aR0, az0, abserr[3]; static gsl_integration_workspace *wksp = NULL; gsl_function FPhi, F_aR, F_az; static double maxerr = 0.0; int stat[3]; if (a == b) { // spherical case is easy! for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { r = absv(Pos(bp)); Phi(bp) = - M / (a + r); mr3i = M * rsqr(r / (a + r)) / rqbe(r); MULVS(Acc(bp), Pos(bp), - mr3i); } } else { // flattened case is harder if (wksp == NULL) { // on first call, initialze wksp = gsl_integration_workspace_alloc(1000); gsl_set_error_handler_off(); // handle errors below } FPhi.function = &intPhi; F_aR.function = &int_aR; F_az.function = &int_az; FPhi.params = F_aR.params = F_az.params = params; a2(params) = rsqr(a); b2(params) = rsqr(b); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { R(params) = rsqrt(rsqr(Pos(bp)[0]) + rsqr(Pos(bp)[1])); z(params) = Pos(bp)[2]; stat[0] = gsl_integration_qagiu(&FPhi, 0.0, tol, 0.0, 1000, wksp, &phi0, &abserr[0]); stat[1] = gsl_integration_qagiu(&F_aR, 0.0, tol, 0.0, 1000, wksp, &aR0, &abserr[1]); stat[2] = gsl_integration_qagiu(&F_az, 0.0, tol, 0.0, 1000, wksp, &az0, &abserr[2]); if (stat[0] || stat[1] || stat[2]) // any errors reported? for (int i = 0; i < 3; i++) if (stat[i] != 0 && abserr[i] > maxerr) { eprintf("[%s.hqmforces: warning: %s abserr[%d] = %g]\n", getprog(), gsl_strerror(stat[i]), i+1, abserr[i]); maxerr = abserr[i]; // adjust reporting threshold } Phi(bp) = - M * phi0; Acc(bp)[0] = - M * (Pos(bp)[0] / R(params)) * aR0; Acc(bp)[1] = - M * (Pos(bp)[1] / R(params)) * aR0; Acc(bp)[2] = - M * az0; } } }
void snaprect(bodyptr btab, int nbody) { matrix qmat, tmpm; bodyptr bp; vector frame[3], tmpv; static vector oldframe[3] = { { 1.0, 0.0, 0.0, }, { 0.0, 1.0, 0.0, }, { 0.0, 0.0, 1.0, }, }; int i; snapcenter(btab, nbody, WeightField.offset); CLRM(qmat); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { OUTVP(tmpm, Pos(bp), Pos(bp)); MULMS(tmpm, tmpm, Weight(bp)); ADDM(qmat, qmat, tmpm); } eigenvect(frame[0], frame[1], frame[2], qmat); if (dotvp(oldframe[0], frame[0]) < 0.0) MULVS(frame[0], frame[0], -1.0); if (dotvp(oldframe[2], frame[2]) < 0.0) MULVS(frame[2], frame[2], -1.0); CROSSVP(frame[1], frame[2], frame[0]); printvect("e_x:", frame[0]); printvect("e_y:", frame[1]); printvect("e_z:", frame[2]); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { if (PosField.offset != BadOffset) { for (i = 0; i < NDIM; i++) tmpv[i] = dotvp(Pos(bp), frame[i]); SETV(Pos(bp), tmpv); } if (VelField.offset != BadOffset) { for (i = 0; i < NDIM; i++) tmpv[i] = dotvp(Vel(bp), frame[i]); SETV(Vel(bp), tmpv); } if (AccField.offset != BadOffset) { for (i = 0; i < NDIM; i++) tmpv[i] = dotvp(Acc(bp), frame[i]); SETV(Acc(bp), tmpv); } if (AuxVecField.offset != BadOffset) { for (i = 0; i < NDIM; i++) tmpv[i] = dotvp(AuxVec(bp), frame[i]); SETV(AuxVec(bp), tmpv); } } for (i = 0; i < NDIM; i++) SETV(oldframe[i], frame[i]); }
void rotate(snapshot *snap, string *tags, string *vecs, char axis, real thetax, real thetay, real thetaz) { matrix rmat; bodyptr bp; switch (tolower(axis)) { case 'x': xmatrix(rmat, thetax); break; case 'y': ymatrix(rmat, thetay); break; case 'z': zmatrix(rmat, thetaz); break; default: error("%s: unknown axis %c\n", getargv0(), axis); } if (set_member(tags, PosTag) && set_member(vecs, PosTag)) for_all_bodies(bp, *snap) rotatevec(Pos(bp), rmat); if (set_member(tags, VelTag) && set_member(vecs, VelTag)) for_all_bodies(bp, *snap) rotatevec(Vel(bp), rmat); if (set_member(tags, AccTag) && set_member(vecs, AccTag)) for_all_bodies(bp, *snap) rotatevec(Acc(bp), rmat); if (set_member(tags, AuxVecTag) && set_member(vecs, AuxVecTag)) for_all_bodies(bp, *snap) rotatevec(AuxVec(bp), rmat); }
nemo_main() { stream instr, quadstr, outstr; Body *btab = NULL, *bp; int nbody, bits; real eps_r, eps_t, tsnap = 0.0; if (!hasvalue("out")) warning("No output supplied (out=)"); quadstr = stropen(getparam("quad"), "r"); get_history(quadstr); instr = stropen(getparam("in"), "r"); get_history(instr); get_quadfield(quadstr, &eps_r, &eps_t); get_snap(instr, &btab, &nbody, &tsnap, &bits); if (bits & PhaseSpaceBit == 0) error("not enuf info: bits = %o", bits); for (bp = btab; bp < btab+nbody; bp++) { CLRV(Acc(bp)); Phi(bp) = 0.0; } quadinter(btab, nbody, eps_r, eps_t); if (hasvalue("out")) { outstr = stropen(getparam("out"), "w"); put_history(outstr); bits = bits | PotentialBit | AccelerationBit; put_snap(outstr, &btab, &nbody, &tsnap, &bits); } }
local void sumforces(bodyptr btab, int nbody, bodyptr gtab, int ngrav, real eps2) { bodyptr bp, gp; double phi0, acc0[NDIM]; vector pos0, dr; real dr2, dr2i, dr1i, mdr1i, mdr3i; for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { phi0 = 0.0; CLRV(acc0); SETV(pos0, Pos(bp)); for (gp = gtab; gp < NthBody(gtab, ngrav); gp = NextBody(gp)) { DOTPSUBV(dr2, dr, Pos(gp), pos0); dr2i = ((real) 1.0) / (dr2 + eps2); dr1i = rsqrt(dr2i); mdr1i = Mass(gp) * dr1i; mdr3i = mdr1i * dr2i; phi0 -= mdr1i; ADDMULVS(acc0, dr, mdr3i); } Phi(bp) = phi0; SETV(Acc(bp), acc0); } }
local void stepsystem(void) { bodyptr p1, p2, p; p1 = bodytab + MAX(nstatic, 0); // set dynamic body range p2 = bodytab + nbody + MIN(nstatic, 0); for (p = p1; p < p2; p++) { // loop over body range ADDMULVS(Vel(p), Acc(p), 0.5 * dtime); // advance v by 1/2 step ADDMULVS(Pos(p), Vel(p), dtime); // advance r by 1 step } treeforce(); for (p = p1; p < p2; p++) { // loop over body range ADDMULVS(Vel(p), Acc(p), 0.5 * dtime); // advance v by 1/2 step } nstep++; // count another time step tnow = tnow + dtime; // finally, advance time }
local void sum1force(bodyptr btab, int nbody, int i0, real eps2) { bodyptr bp0, bp; double phi0, acc0[NDIM]; vector pos0, dr; real dr2, drab, mri, mr3i; int j; bp0 = NthBody(btab, i0); phi0 = 0.0; CLRV(acc0); SETV(pos0, Pos(bp0)); for (j = 0; j < nbody; j++) if (j != i0) { bp = NthBody(btab, j); DOTPSUBV(dr2, dr, Pos(bp), pos0); dr2 += eps2; drab = rsqrt(dr2); mri = Mass(bp) / drab; phi0 -= mri; mr3i = mri / dr2; ADDMULVS(acc0, dr, mr3i); } Phi(bp0) = phi0; SETV(Acc(bp0), acc0); }
EXTERN_ENV #define global extern #include "stdinc.h" /* * HACKGRAV: evaluate grav field at a given particle. */ void hackgrav(bodyptr p, long ProcessId) { Local[ProcessId].pskip = p; SETV(Local[ProcessId].pos0, Pos(p)); Local[ProcessId].phi0 = 0.0; CLRV(Local[ProcessId].acc0); Local[ProcessId].myn2bterm = 0; Local[ProcessId].mynbcterm = 0; Local[ProcessId].skipself = FALSE; hackwalk(ProcessId); Phi(p) = Local[ProcessId].phi0; SETV(Acc(p), Local[ProcessId].acc0); #ifdef QUADPOLE Cost(p) = Local[ProcessId].myn2bterm + NDIM * Local[ProcessId].mynbcterm; #else Cost(p) = Local[ProcessId].myn2bterm + Local[ProcessId].mynbcterm; #endif }
int main() { Acc a(1); a(5); Acc(3); std::cout << a(2.3f); return 0; }
void nemo_main() { stream instr, outstr; string times, ctypei, ctypeo; real tsnap; int i, nbody, bits, mode; Body *btab = NULL, *bp; proc transform, trans2; times = getparam("times"); ctypei = getparam("ctypei"); ctypeo = getparam("ctypeo"); if (streq(ctypei,"cart") && streq(ctypeo,"sph")) transform = cartesian_spherical; else if (streq(ctypei,"sph") && streq(ctypeo,"cart")) transform = spherical_cartesian; else if (streq(ctypei,"cart") && streq(ctypeo,"cyl")) transform = cartesian_cylindrical; else if (streq(ctypei,"cyl") && streq(ctypeo,"cart")) transform = cylindrical_cartesian; else error("Unimplemented ctype i/o : %s -> %s",ctypei,ctypeo); dprintf(0,"converting from %s to %s\n",ctypei,ctypeo); instr = stropen(getparam("in"), "r"); outstr = stropen(getparam("out"), "w"); get_history(instr); put_history(outstr); for (;;) { get_history(instr); /* skip over stuff we can forget */ if (!get_tag_ok(instr, SnapShotTag)) break; /* done with work in loop */ get_snap(instr, &btab, &nbody, &tsnap, &bits); if ((bits & MassBit) == 0 && (bits & PhaseSpaceBit) == 0) { continue; /* just skip it's probably a diagnostics */ } if ((bits & TimeBit) == 0) tsnap = 0.0; else if (!streq(times,"all") && !within(tsnap, times, TIMEFUZZ)) continue; dprintf (1,"Transforming snapshot at time= %f bits=0x%x\n",tsnap,bits); #if 0 Qmass = MassBit & bits; Qphase = PhaseSpaceBit & bits; Qacc = AccelerationBit & bits; Qaux = AuxBit & bits; Qkey = KeyBit & bits; #endif for (bp = btab; bp < btab+nbody; bp++) { (transform)(Pos(bp),Vel(bp),Acc(bp)); } put_snap(outstr, &btab, &nbody, &tsnap, &bits); } }
void PCommands::doCmdkick() { bool SyntaxError = false; if(ArgC < 1) { SyntaxError = true; } if(SyntaxError == true) { Chat->send(source, CHAT_DIRECT, "Usage", "@kick <charID or nickname>"); return; } if(IsArgNumeric(1) == true) { target = GetClientByID(GetArgInt(1)); } else { char tmp_destNick[50]; GetArgText(1, tmp_destNick, 50); target = GetClientByNick(tmp_destNick); } if(target == NULL) // If victim isnt found, return error { Chat->send(source, CHAT_DIRECT, "System", "No such player"); return; } // Make sure only people with a higher level than victim can kick victim if(source->GetAccountLevel() <= target->GetAccountLevel()) { char tmpMsg[200]; snprintf(tmpMsg, 199, "Cant kick %s, target level is higher or equal to yours!", Chars->GetChar(target->GetCharID())->GetName().c_str()); tmpMsg[199] = '\0'; Chat->send(source, CHAT_DIRECT, "System", tmpMsg); return; } // *************** Checks done, proceed with command int final_bantime = std::time(NULL) + 60; // Ban 60 seconds (Anti-Rejoin) PAccount Acc(target->GetAccountID()); Acc.SetBannedUntilTime(final_bantime); Acc.Save(); target->InitCharVanish(); GameServer->ClientDisconnected(target); // Kick Console->Print("%s %s (Lv %d) kicked %s (Lv %d)", Console->ColorText(YELLOW, BLACK, "[GameCommand]"), Chars->GetChar(source->GetCharID())->GetName().c_str(), source->GetAccountLevel(), Chars->GetChar(target->GetCharID())->GetName().c_str(), target->GetAccountLevel()); char successmsg[100]; snprintf(successmsg, 99, "Kicked %s", Chars->GetChar(target->GetCharID())->GetName().c_str()); successmsg[99] = '\0'; Chat->send(source, CHAT_DIRECT, "System", successmsg); }
local void gspforces(bodyptr btab, int nbody, gsprof *gravgsp) { bodyptr bp; real r, mr3i; for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { r = absv(Pos(bp)); Phi(bp) = phi_gsp(gravgsp, r); mr3i = mass_gsp(gravgsp, r) / rqbe(r); MULVS(Acc(bp), Pos(bp), -mr3i); } }
void snapcmacc(vector cmacc, bodyptr btab, int nbody, int woff) { double wtot, cmtmp[NDIM]; bodyptr bp; wtot = 0.0; CLRV(cmtmp); for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { wtot = wtot + Weight(bp, woff); ADDMULVS(cmtmp, Acc(bp), Weight(bp, woff)); } DIVVS(cmacc, cmtmp, wtot); }
void Impostor::AddSample( vcg::Point3f p, vcg::Point3f n, vcg::Color4b c){ if(box.IsIn(p)){ const int ii = std::min<int>( int((p[0]-box.min[0])/cellsize),Gridsize()-1); const int jj = std::min<int>( int((p[1]-box.min[1])/cellsize),Gridsize()-1); const int kk = std::min<int>( int((p[2]-box.min[2])/cellsize),Gridsize()-1); if(n_samples.IsOn(ii,jj,kk)){ assert(n_samples.At(ii,jj,kk) != 0); centroids.At(ii,jj,kk) = Acc(centroids.At(ii,jj,kk),F2C(p,ii,jj,kk),n_samples.At(ii,jj,kk)); normals.At(ii,jj,kk) = Acc(normals.At(ii,jj,kk),F2C_01(n),n_samples.At(ii,jj,kk)); colors.At(ii,jj,kk) = Acc_0_255(colors.At(ii,jj,kk),F2C(c),n_samples.At(ii,jj,kk)); ++n_samples.At(ii,jj,kk); } else{ n_samples.At(ii,jj,kk) = 1; centroids.At(ii,jj,kk) = F2C(p,ii,jj,kk); normals.At(ii,jj,kk) = F2C_01(n); colors.At(ii,jj,kk) = F2C(c); } } }
int main (void) { InitUart(); //Init uart initInput(); //Init interrupt to start button, stop button and speed sensor initMotorPWM(); //Init Fast PWM on Timer 0 (Pin PE1) initSpeedTimer(); //Init Timer 1 (16bit normal mode) initCurrentADC(); //Init ADC on PC5 //Init speed array for (int i = 0; i<(SPEED_ARRAY_SIZE); i++) { speedArray[i]=65535; } while (1) { //Switch to stop state if something is rotten Protection(&Sm_State, &speed); switch (Sm_State) { case STATE_STOP: Stop(&motor); break; case STATE_RAMP_INIT: RampInit(&Sm_State, &motor); break; case STATE_RAMP_SEARCH: RampSearch(&Sm_State, &motor, &speed, &lastSpeed); break; case STATE_ACC: Acc(&Sm_State,&motor, speedArray); break; case STATE_COAST: Coast(&Sm_State, &motor, &speed); break; default: Sm_State = STATE_STOP; break; } } }
local void diagnostics() { bodyptr p; real velsq, phi0; vector tmpv; matrix tmpt; int ndim=NDIM; mtot = 0.0; /* zero total mass */ etot[1] = etot[2] = 0.0; /* zero total KE and PE */ CLRM(keten); /* zero ke tensor */ CLRM(peten); /* zero pe tensor */ CLRM(amten); /* zero am tensor */ CLRV(cmphase[0]); /* zero c. of m. position */ CLRV(cmphase[1]); /* zero c. of m. velocity */ for (p = bodytab; p < bodytab+nbody; p++) { /* loop over all particles */ mtot += Mass(p); /* sum particle masses */ DOTVP(velsq, Vel(p), Vel(p)); /* square vel vector */ if (extpot) { /* external potential corr. */ (*extpot)(&ndim,Pos(p),tmpv,&phi0,&tnow); phi0 = Phi(p) + phi0; /* extre correction */ } else phi0 = Phi(p); etot[1] += 0.5 * Mass(p) * velsq; /* sum current KE */ etot[2] += 0.5 * Mass(p) * phi0; /* and current PE */ MULVS(tmpv, Vel(p), 0.5 * Mass(p)); /* sum 0.5 m v_i v_j */ OUTVP(tmpt, tmpv, Vel(p)); ADDM(keten, keten, tmpt); MULVS(tmpv, Pos(p), Mass(p)); /* sum m r_i a_j */ OUTVP(tmpt, tmpv, Acc(p)); ADDM(peten, peten, tmpt); OUTVP(tmpt, tmpv, Vel(p)); /* sum m r_i v_j */ ADDM(amten, amten, tmpt); MULVS(tmpv, Pos(p), Mass(p)); /* sum cm position */ ADDV(cmphase[0], cmphase[0], tmpv); MULVS(tmpv, Vel(p), Mass(p)); /* sum cm momentum */ ADDV(cmphase[1], cmphase[1], tmpv); } etot[0] = etot[1] + etot[2]; /* sum KE and PE */ TRANM(tmpt, amten); /* anti-sym. AM tensor */ SUBM(amten, amten, tmpt); DIVVS(cmphase[0], cmphase[0], mtot); /* normalize cm coords */ DIVVS(cmphase[1], cmphase[1], mtot); }
void hackgrav(bodyptr p, bool intree) { pskip = p; /* exclude p from f.c. */ SETV(pos0, PosB(p)); /* set field point */ phi0 = 0.0; /* init total potential */ CLRV(acc0); /* and total acceleration */ n2bterm = nbcterm = 0; /* count body & cell terms */ skipself = FALSE; /* watch for tree-incest */ treescan((nodeptr) &root->cellnode); /* scan tree from root */ if (intree && ! skipself) { /* did tree-incest occur? */ if (! scanopt(options, "allow-incest")) /* treat as catastrophic? */ error("hackgrav: tree-incest detected\n"); if (! treeincest) /* for the first time? */ eprintf("\n[hackgrav: tree-incest detected]\n"); treeincest = TRUE; /* don't repeat warning */ } Phi(p) = phi0; /* store total potential */ SETV(Acc(p), acc0); /* and acceleration */ }
local void gravsum(bodyptr p0, cellptr cptr, cellptr bptr) { vector pos0, acc0; real phi0; SETV(pos0, Pos(p0)); // copy position of body phi0 = 0.0; // init total potential CLRV(acc0); // and total acceleration if (usequad) // if using quad moments sumcell(interact, cptr, pos0, &phi0, acc0); // sum cell forces w quads else // not using quad moments sumnode(interact, cptr, pos0, &phi0, acc0); // sum cell forces wo quads sumnode(bptr, interact + actmax, pos0, &phi0, acc0); // sum forces from bodies Phi(p0) = phi0; // store total potential SETV(Acc(p0), acc0); // and total acceleration nfcalc++; // update counters nbbcalc += interact + actmax - bptr; nbccalc += cptr - interact; }
local void diagnostics(void) { bodyptr p1, p2, p; real mp, velsq; vector tmpv; matrix tmpt; mtot = 0.0; // zero total mass etot[1] = etot[2] = 0.0; // zero total KE and PE CLRM(keten); // zero ke tensor CLRM(peten); // zero pe tensor CLRV(amvec); // zero am vector CLRV(cmpos); // zero c. of m. position CLRV(cmvel); // zero c. of m. velocity p1 = bodytab + MAX(nstatic, 0); // set dynamic body range p2 = bodytab + nbody + MIN(nstatic, 0); for (p = p1; p < p2; p++) { // loop over body range mp = (testcalc ? 1.0 / (nbody - ABS(nstatic)) : Mass(p)); // use eq. mass in testcalc mtot += mp; // sum particle masses DOTVP(velsq, Vel(p), Vel(p)); // square vel vector etot[1] += 0.5 * mp * velsq; // sum current KE etot[2] += (testcalc ? 1.0 : 0.5) * mp * Phi(p); // and PE, weighted right MULVS(tmpv, Vel(p), 0.5 * mp); // sum 0.5 m v_i v_j OUTVP(tmpt, tmpv, Vel(p)); ADDM(keten, keten, tmpt); MULVS(tmpv, Pos(p), mp); // sum m r_i a_j OUTVP(tmpt, tmpv, Acc(p)); ADDM(peten, peten, tmpt); CROSSVP(tmpv, Vel(p), Pos(p)); // sum angular momentum MULVS(tmpv, tmpv, mp); ADDV(amvec, amvec, tmpv); MULVS(tmpv, Pos(p), mp); // sum cm position ADDV(cmpos, cmpos, tmpv); MULVS(tmpv, Vel(p), mp); // sum cm momentum ADDV(cmvel, cmvel, tmpv); } etot[0] = etot[1] + etot[2]; // sum KE and PE DIVVS(cmpos, cmpos, mtot); // normalize cm coords DIVVS(cmvel, cmvel, mtot); }
local void diagnostics() { int i; Body *p; real velsq; vector tmpv; matrix tmpt; mtot = 0.0; /* zero total mass */ etot[1] = etot[2] = 0.0; /* zero total KE and PE */ CLRM(keten); /* zero KE tensor */ CLRM(peten); /* zero PE tensor */ CLRM(amten); /* zero AM tensor */ CLRV(cmphase[0]); /* zero c. of m. position */ CLRV(cmphase[1]); /* zero c. of m. velocity */ for (p = bodytab; p < bodytab+nbody; p++) { /* loop over all bodies */ mtot += Mass(p); /* sum body masses */ DOTVP(velsq, Vel(p), Vel(p)); /* square vel vector */ etot[1] += 0.5 * Mass(p) * velsq; /* sum current KE */ etot[2] += 0.5 * Mass(p) * Phi(p); /* and current PE */ MULVS(tmpv, Vel(p), 0.5 * Mass(p)); /* sum 0.5 m v_i v_j */ OUTVP(tmpt, tmpv, Vel(p)); ADDM(keten, keten, tmpt); MULVS(tmpv, Pos(p), Mass(p)); /* sum m r_i a_j */ OUTVP(tmpt, tmpv, Acc(p)); ADDM(peten, peten, tmpt); OUTVP(tmpt, tmpv, Vel(p)); /* sum m r_i v_j */ ADDM(amten, amten, tmpt); MULVS(tmpv, Pos(p), Mass(p)); /* sum cm position */ ADDV(cmphase[0], cmphase[0], tmpv); MULVS(tmpv, Vel(p), Mass(p)); /* sum cm momentum */ ADDV(cmphase[1], cmphase[1], tmpv); } etot[0] = etot[1] + etot[2]; /* sum KE and PE */ TRANM(tmpt, amten); /* antisymmetrize AM tensor */ SUBM(amten, amten, tmpt); DIVVS(cmphase[0], cmphase[0], mtot); /* normalize cm coords */ DIVVS(cmphase[1], cmphase[1], mtot); }
local void gravsum(bodyptr p0, cellptr cptr, cellptr bptr) { vector pos0, acc0; real phi0; SETV(pos0, Pos(p0)); /* copy position of body */ phi0 = 0.0; /* init total potential */ CLRV(acc0); /* and total acceleration */ if (usequad) /* if using quad moments */ sumcell(interact, cptr, pos0, &phi0, acc0); /* sum cell forces w quads */ else /* not using quad moments */ sumnode(interact, cptr, pos0, &phi0, acc0); /* sum cell forces wo quads */ sumnode(bptr, interact + actlen, pos0, &phi0, acc0); /* sum forces from bodies */ Phi(p0) = phi0; /* store total potential */ SETV(Acc(p0), acc0); /* and total acceleration */ nfcalc++; /* update counters */ nbbcalc += interact + actlen - bptr; nbccalc += cptr - interact; }
// treeforce: supervise force calculation. // _______________________________________ local void treeforce(void) { bodyptr p1, p2, p; real r, mr3i; p1 = bodytab + MAX(nstatic, 0); // set dynamic body range p2 = bodytab + nbody + MIN(nstatic, 0); for (p = bodytab; p < bodytab+nbody; p++) // loop over all bodies Update(p) = (testcalc ? p1 <= p && p < p2 : TRUE); // flag bodies to update maketree(bodytab, nbody); // construct tree structure gravcalc(); // compute current forces forcereport(); // print force statistics #if defined(EXTGRAV) for (p = bodytab; p < bodytab+nbody; p++) // loop over all bodies if (Update(p) && gravgsp != NULL) { // update in extern field? r = absv(Pos(p)); // get distance from origin mr3i = - mass_gsp(gravgsp, r) / (r*r*r); ADDMULVS(Acc(p), Pos(p), mr3i); // add extern acc and phi Phi(p) += phi_gsp(gravgsp, r); } #endif }
void force_calc(void) { real *pp, *ap; double cpubase; string *rminxstr; int i; bodyptr bp; tol = getdparam("tol"); eps = getdparam("eps"); rsize = getdparam("rsize"); rminxstr = burststring(getparam("rmin"), ", "); if (xstrlen(rminxstr, sizeof(string)) < NDIM) { SETVS(rmin, - rsize / 2.0); } else for (i = 0; i < NDIM; i++) rmin[i] = atof(rminxstr[i]); dprintf(0,"initial rsize: %8f rmin: %8f %8f %8f\n", rsize, rmin[0], rmin[1], rmin[2]); fcells = getdparam("fcells"); phidata = pp = (real *) allocate(ntest * sizeof(real)); accdata = ap = (real *) allocate(ntest * NDIM * sizeof(real)); cpubase = cputime(); maketree(massdata, nmass); cputree = cputime() - cpubase; dprintf(0," final rsize: %8f rmin: %8f %8f %8f\n", rsize, rmin[0], rmin[1], rmin[2]); cpubase = cputime(); n2btot = nbctot = 0; for (bp = testdata; bp < testdata+ntest; bp++) { hackgrav(bp); *pp++ = Phi(bp); SETV(ap, Acc(bp)); ap += NDIM; n2btot += n2bterm; nbctot += nbcterm; } cpufcal = cputime() - cpubase; }
//--------------------------------------------------------- // Acc //--------------------------------------------------------- struct Acc { const char* tag; // for use in xml file const char* name; // translated name int offset; // semitone offset int centOffset; int sym; Acc(const char* t, const char* n, int o, int o2, int s) : tag(t), name(n), offset(o), centOffset(o2), sym(s) {} }; Acc accList[] = { Acc("none", QT_TRANSLATE_NOOP("accidental", "none"), 0, 0, -1), Acc("sharp", QT_TRANSLATE_NOOP("accidental", "sharp"), 1, 0, sharpSym), Acc("flat", QT_TRANSLATE_NOOP("accidental", "flat"), -1, 0, flatSym), Acc("double sharp", QT_TRANSLATE_NOOP("accidental", "double sharp"), 2, 0, sharpsharpSym), Acc("double flat", QT_TRANSLATE_NOOP("accidental", "double flat"), -2, 0, flatflatSym), Acc("natural", QT_TRANSLATE_NOOP("accidental", "natural"), 0, 0, naturalSym), Acc("flat-slash", QT_TRANSLATE_NOOP("accidental", "flat-slash"), 0, 0, flatslashSym), Acc("flat-slash2", QT_TRANSLATE_NOOP("accidental", "flat-slash2"), 0, 0, flatslash2Sym), Acc("mirrored-flat2", QT_TRANSLATE_NOOP("accidental", "mirrored-flat2"), 0, 0, mirroredflat2Sym), Acc("mirrored-flat", QT_TRANSLATE_NOOP("accidental", "mirrored-flat"), 0, 0, mirroredflatSym), Acc("mirrored-flat-slash", QT_TRANSLATE_NOOP("accidental", "mirrored-flat-slash"), 0, 0, mirroredflatslashSym), Acc("flat-flat-slash", QT_TRANSLATE_NOOP("accidental", "flat-flat-slash"), 0, 0, flatflatslashSym), Acc("sharp-slash", QT_TRANSLATE_NOOP("accidental", "sharp-slash"), 0, 0, sharpslashSym), Acc("sharp-slash2", QT_TRANSLATE_NOOP("accidental", "sharp-slash2"), 0, 0, sharpslash2Sym),
void print_data(bodyptr btab, int nbody, real tnow, string *fields, string ifmt, string rfmt) { bodyptr bp; for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { if (set_member(fields, TimeTag)) printf(rfmt, tnow); if (set_member(fields, MassTag)) printf(rfmt, Mass(bp)); if (set_member(fields, PosTag)) { printf(rfmt, Pos(bp)[0]); printf(rfmt, Pos(bp)[1]); printf(rfmt, Pos(bp)[2]); } if (set_member(fields, VelTag)) { printf(rfmt, Vel(bp)[0]); printf(rfmt, Vel(bp)[1]); printf(rfmt, Vel(bp)[2]); } if (set_member(fields, AccTag)) { printf(rfmt, Acc(bp)[0]); printf(rfmt, Acc(bp)[1]); printf(rfmt, Acc(bp)[2]); } if (set_member(fields, PhiTag)) printf(rfmt, Phi(bp)); if (set_member(fields, SmoothTag)) printf(rfmt, Smooth(bp)); if (set_member(fields, RhoTag)) printf(rfmt, Rho(bp)); if (set_member(fields, EntFuncTag)) printf(rfmt, EntFunc(bp)); if (set_member(fields, UinternTag)) printf(rfmt, Uintern(bp)); if (set_member(fields, UdotIntTag)) printf(rfmt, UdotInt(bp)); if (set_member(fields, UdotRadTag)) printf(rfmt, UdotRad(bp)); if (set_member(fields, UdotVisTag)) printf(rfmt, UdotVis(bp)); if (set_member(fields, TauTag)) printf(rfmt, Tau(bp)); if (set_member(fields, BirthTag)) printf(rfmt, Birth(bp)); if (set_member(fields, DeathTag)) printf(rfmt, Death(bp)); if (set_member(fields, TypeTag)) printf(ifmt, (int) Type(bp)); if (set_member(fields, KeyTag)) printf(ifmt, Key(bp)); if (set_member(fields, AuxTag)) printf(rfmt, Aux(bp)); if (set_member(fields, AuxVecTag)) { printf(rfmt, AuxVec(bp)[0]); printf(rfmt, AuxVec(bp)[1]); printf(rfmt, AuxVec(bp)[2]); } printf("\n"); } }
int main(int argc, string argv[]) { stream istr, ostr, gstr; real tnow, tgrav, eps2, tstop, dtime, tout, Mhqm, ahqm, bhqm, tol; real decrit, epot0, demin, demax, derms, de2avg, enow, denow; int nbody, ngrav; bodyptr btab = NULL, gtab = NULL, bp; string bdtags[MaxBodyFields], grtags[MaxBodyFields], *optags; gsprof *gravgsp = NULL; bool decrit_inc = FALSE; initparam(argv, defv); new_field(&EinitPBF, RealType, EinitTag); // define initial energy field layout_body(bodytags, Precision, NDIM); // layout necessary fields istr = stropen(getparam("in"), "r"); get_history(istr); if (! get_snap(istr, &btab, &nbody, &tnow, bdtags, TRUE)) error("%s: can't read input snapshot\n", getprog()); if (! (set_member(bdtags, PosTag) && set_member(bdtags, VelTag))) error("%s: required data missing from input snapshot\n", getprog()); #if defined(NBDGRAV) gstr = stropen(getparam("grav"), "r"); get_history(gstr); if (! get_snap(gstr, >ab, &ngrav, &tgrav, grtags, FALSE)) error("%s: can't read gravity snapshot\n", getprog()); if (! (set_member(grtags, MassTag) && set_member(grtags, PosTag))) error("%s: required data missing from gravity snapshot\n", getprog()); eps2 = rsqr(getdparam("eps")); #elif defined(GSPGRAV) gstr = stropen(getparam("grav"), "r"); get_history(gstr); gravgsp = get_gsprof(gstr); // read GSP for grav. field #elif defined(HQMGRAV) Mhqm = getdparam("M"); ahqm = getdparam("a"); bhqm = getdparam("b"); tol = getdparam("tol"); #endif ostr = stropen(getparam("out"), "w"); put_history(ostr); tstop = getdparam("tstop"); dtime = getdparam("dtime"); decrit = getdparam("decrit"); optags = burststring(getparam("outputs"), ","); #if defined(NBDGRAV) sumforces(btab, nbody, gtab, ngrav, eps2); // prime the pump... #elif defined(GSPGRAV) gspforces(btab, nbody, gravgsp); #elif defined(HQMGRAV) hqmforces(btab, nbody, Mhqm, ahqm, bhqm, tol); #endif epot0 = 0.0; // use as energy scale for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { epot0 += Phi(bp) / nbody; // compute avg. potential Einit(bp) = Phi(bp) + dotvp(Vel(bp), Vel(bp)) / 2; } eprintf("[%s: initial average potential = %g]\n", getprog(), epot0); put_snap(ostr, &btab, &nbody, &tnow, optags); fflush(NULL); tout = tnow + getdparam("dtout"); demin = demax = derms = 0.0; // track maximum errors while (tnow < tstop) { // enter main loop for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { ADDMULVS(Vel(bp), Acc(bp), 0.5 * dtime); // step velocities by dt/2 ADDMULVS(Pos(bp), Vel(bp), dtime); // step positions by dt } tnow = tnow + dtime; // step time to new value #if defined(NBDGRAV) if (! getbparam("frozen")) if (! get_snap(gstr, >ab, &ngrav, &tgrav, grtags, TRUE)) error("%s: can't read gravity snapshot\n", getprog()); sumforces(btab, nbody, gtab, ngrav, eps2); // get new accelerations #elif defined(GSPGRAV) gspforces(btab, nbody, gravgsp); #elif defined(HQMGRAV) hqmforces(btab, nbody, Mhqm, ahqm, bhqm, tol); #endif de2avg = 0.0; for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) { ADDMULVS(Vel(bp), Acc(bp), 0.5 * dtime); // step velocities by dt/2 enow = 0.5 * dotvp(Vel(bp), Vel(bp)) + Phi(bp); denow = (enow - Einit(bp)) / ABS(epot0); // compute rel. energy change demin = MIN(demin, denow); demax = MAX(demax, denow); de2avg += rsqr(denow) / nbody; } derms = MAX(derms, rsqrt(de2avg)); if (demin < -decrit || demax > decrit) { eprintf("[%s: warning: energy error exceeds %.4e at time = %-12.8f\n" " min,max,rms = %.6g,%.6g,%.6g threshold now %.4e]\n", getprog(), decrit, tnow, demin, demax, rsqrt(de2avg), decrit * rsqrt(2.0)); decrit = decrit * rsqrt(2.0); decrit_inc = TRUE; } if (tout <= tnow) { put_snap(ostr, &btab, &nbody, &tnow, optags); tout = tout + getdparam("dtout"); } fflush(NULL); } eprintf(decrit_inc ? "[%s: WARNING: energy error: min,max,rms = %.6g,%.6g,%.6g]\n" : "[%s: energy error: min,max,rms = %.6g,%.6g,%.6g]\n", getprog(), demin, demax, derms); return (0); }
bool PGameServer::HandleCharList( PClient *Client, PGameState *State, const u8 *Packet, int PacketSize ) { static u8 Answer[10] = {0xfe, 0x07, 0x00, 0x83, 0x86, 0, 0, 0, 0, 0}; ConnectionTCP *Socket = Client->getTCPConn(); if ( PacketSize > 9 && *( u16* )&Packet[3] == 0x8284 ) { u8 Mode = Packet[9]; switch ( Mode ) { case 6: // request list return ( HandleRequestChars( Client, State, Packet ) ); case 5: // validate name { if ( PacketSize < 31 ) return ( false ); // check for valid name string bool ValidString = false; for ( int i = 30; i < PacketSize; i++ ) if ( Packet[i] == 0 ) { ValidString = true; break; } const char *Name = ( char* ) & Packet[30]; if ( ValidString ) { ValidString = PChar::IsCharnameWellFormed( Name ); } if ( ValidString ) { if ( Chars->CharExist( std::string( Name ) ) ) { ValidString = false; } } if ( ValidString ) Answer[5] = 1; // ok else Answer[5] = 2; // 2..6 => 'char name already in use!' // Answer[5] = 0; // => 'unknown error' Socket->write( Answer, 10 ); return ( true ); } case 3: // delete char { PAccount Acc( Client->GetAccountID() ); u8 Num = Packet[PacketSize-1]; if ( Acc.GetID() ) { u32 CharID = Acc.GetCharIdBySlot( Num ); // Also check that char is out of game if (( CharID != 0 ) && ( Chars->GetChar( CharID ) == NULL ) ) { char query[100]; snprintf( query, 100, "DELETE FROM characters WHERE c_id = %d LIMIT 1", CharID ); if ( MySQL->GameQuery( query ) ) Console->Print( RED, BLACK, "[Notice] Char %d not deleted!", CharID ); else { Console->Print( GREEN, BLACK, "[Info] Char %d deleted!", CharID ); snprintf( query, 100, "DELETE FROM buddy_list WHERE bud_charid = %d", CharID ); if ( MySQL->GameQuery( query ) ) Console->Print( YELLOW, BLACK, "[Notice] Char %d's buddy list not removed!", CharID ); snprintf( query, 100, "DELETE FROM genrep WHERE g_charid = %d", CharID ); if ( MySQL->GameQuery( query ) ) Console->Print( YELLOW, BLACK, "[Notice] Char %d's genrep list not removed!", CharID ); snprintf( query, 100, "DELETE FROM inventory WHERE inv_charid = %d", CharID ); if ( MySQL->GameQuery( query ) ) Console->Print( YELLOW, BLACK, "[Notice] Char %d's inventory not removed!", CharID ); Appartements->DeleteCharAppartements( CharID ); } } else return false; } return ( true ); } case 7: // create char { if ( PacketSize < 64 ) return ( false ); u32 Slot = * ( u32* ) & Packet[30]; //u32 nClass =* (u32*)&Packet[34]; // Not used - indirectly redundant with Profession u32 Profession = * ( u32* ) & Packet[38]; u32 Gender = * ( u32* ) & Packet[42]; u32 Head = * ( u32* ) & Packet[46]; u32 Torso = * ( u32* ) & Packet[50]; u32 Legs = * ( u32* ) & Packet[54]; u32 Faction = * ( u32* ) & Packet[58]; u8 NameLen = Packet[62]; u8 NZSNb = Packet[63]; char TempName[256]; std::strncpy( TempName, ( const char* )&Packet[64], NameLen ); TempName[NameLen] = 0; Answer[5] = 2; // return error if char creation fails if ( PChar::IsCharnameWellFormed( TempName ) ) { // check for already used char name - should not happen though if ( ! Chars->CharExist( std::string( TempName ) ) ) { PAccount Acc( Client->GetAccountID() ); PChar* nChar = new PChar(); if ( nChar->CreateNewChar( Acc.GetID(), TempName, Gender, Profession, Faction, Head, Torso, Legs, NZSNb, ( const char* )&Packet[64+NameLen], Slot ) ) { Answer[5] = 1; // return success } delete nChar; } } Socket->write( Answer, 10 ); return ( true ); } } } else { Console->Print( RED, BLACK, "[Notice] Gameserver protocol error (GS_CHARLIST): invalid packet [%04x]", *( u16* )&Packet[3] ); return ( false ); } return true; }
plotsnap() { real t, *mp, *psp, *pp, *ap, *acp; int vismax, visnow, i, vis, icol; real psz, col, x, y, z; Body b; bool Qall = FALSE; t = (timeptr != NULL ? *timeptr : 0.0); /* get current time value */ CLRV(Acc(&b)); /* zero unsupported fields */ Key(&b) = 0; visnow = vismax = 0; do { /* loop painting layers */ visnow++; /* make next layer visib. */ mp = massptr; /* (re)set data pointers */ psp = phaseptr; pp = phiptr; ap = auxptr; acp = accptr; npnt = 0; for (i = 0; i < nbody; i++) { /* loop over all bodies */ Mass(&b) = (mp != NULL ? *mp++ : 0.0); /* set mass if supplied */ SETV(Pos(&b), psp); /* always set position */ psp += NDIM; /* and advance p.s. ptr */ SETV(Vel(&b), psp); /* always set velocity */ psp += NDIM; /* and advance ptr */ Phi(&b) = (pp != NULL ? *pp++ : 0.0); Aux(&b) = (ap != NULL ? *ap++ : 0.0); if (acp) { SETV(Acc(&b),acp); /* set accel's */ acp += NDIM; /* and advance ptr */ } /* set phi,aux if given */ vis = (*vfunc)(&b, t, i); /* evaluate visibility */ vismax = MAX(vismax, vis); /* remember how hi to go*/ if (vis == visnow) { /* if body is visible */ x = (*xfunc)(&b, t, i); /* evaluate x,y,z coords*/ y = (*yfunc)(&b, t, i); z = (*zfunc)(&b, t, i); psz = (*pfunc)(&b, t, i); #define MAXCOLOR 16 #ifdef COLOR col = (*cfunc)(&b, t, i); col = (col - crange[0])/(crange[1] - crange[0]); icol = 1 + (MAXCOLOR - 2) * MAX(0.0, MIN(1.0, col)); s2sci(icol); #endif xpnt[npnt] = x; ypnt[npnt] = y; zpnt[npnt] = z; if (!Qall) { s2pt1(xpnt[npnt],ypnt[npnt],zpnt[npnt], visnow); } npnt++; } } /* i<nbody */ if (Qall) s2pt(npnt, xpnt, ypnt, zpnt, visnow); } while (visnow < vismax); /* until final layer done */ }
void PCommands::doCmdban() { bool SyntaxError = false; if(ArgC < 2) { SyntaxError = true; } if(SyntaxError == true) { Chat->send(source, CHAT_DIRECT, "Usage", "@ban <charID or nickname> <xS(econds)>/<xM(inutes)>/<xH(ours)>/<xD(ays)>"); return; } if(IsArgNumeric(1) == true) { target = GetClientByID(GetArgInt(1)); } else { char tmp_destNick[50]; GetArgText(1, tmp_destNick, 50); target = GetClientByNick(tmp_destNick); } if(target == NULL) // If victim isnt found, return error { Chat->send(source, CHAT_DIRECT, "System", "No such player"); return; } if(source->GetAccountLevel() <= target->GetAccountLevel()) { char tmpMsg[200]; snprintf(tmpMsg, 199, "Cant ban %s, target level is higher or equal to yours!", Chars->GetChar(target->GetCharID())->GetName().c_str()); tmpMsg[199] = '\0'; Chat->send(source, CHAT_DIRECT, "System", tmpMsg); return; } char tmpTimeVal[10]; GetArgText(2, tmpTimeVal, 10); int loop_i = 0; char tmp_atoi[10]; while(isdigit(tmpTimeVal[loop_i]) != 0 && loop_i < 10) { tmp_atoi[loop_i] = tmpTimeVal[loop_i]; loop_i++; } char timefactor[1]; timefactor[0] = tmpTimeVal[loop_i]; int timevalue = atoi(tmp_atoi); int time_to_ban = 0; if(strcasecmp(timefactor, "s") == 0 ) { time_to_ban = timevalue; } else if(strcasecmp(timefactor, "m") == 0 ) { time_to_ban = timevalue * 60; } else if(strcasecmp(timefactor, "h") == 0 ) { time_to_ban = timevalue * 60 * 60; } else if(strcasecmp(timefactor, "d") == 0 ) { time_to_ban = timevalue * 60 * 60 * 24; } else { Chat->send(source, CHAT_DIRECT, "Usage", "@ban <charID or nickname> <xS(econds)>/<xM(inutes)>/<xH(ours)>/<xD(ays)>"); return; } int final_bantime = std::time(NULL) + time_to_ban; PAccount Acc(target->GetAccountID()); Acc.SetBannedUntilTime(final_bantime); Acc.Save(); target->InitCharVanish(); GameServer->ClientDisconnected(target); // Now kick the player (Hes banned :) ) char tmpMsg_success[81]; snprintf(tmpMsg_success, 80, "Successfully banned %s", target->GetChar()->GetName().c_str()); tmpMsg_success[80] = '\0'; Chat->send(source, CHAT_DIRECT, "System", tmpMsg_success); return; }