void AddWrite( Bit32u regFull, Bit8u val ) { Bit8u regMask = regFull & 0xff; /* Do some special checks if we're doing opl3 or dualopl2 commands Although you could pretty much just stick to always doing opl3 on the player side */ //Enabling opl3 4op modes will make us go into opl3 mode if ( header.hardware != HW_OPL3 && regFull == 0x104 && val && (*cache)[0x105] ) { header.hardware = HW_OPL3; } //Writing a keyon to a 2nd address enables dual opl2 otherwise //Maybe also check for rhythm if ( header.hardware == HW_OPL2 && regFull >= 0x1b0 && regFull <=0x1b8 && val ) { header.hardware = HW_DUALOPL2; } Bit8u raw = ToRaw[ regMask ]; if ( raw == 0xff ) return; if ( regFull & 0x100 ) raw |= 128; AddBuf( raw, val ); }
static int addWLenBuf(uint8_t **ppCur, uint32_t *pdwLeft, const uint8_t *pBuf, uint32_t dwBufLen, int iNetByteOrder) { assert((ppCur && *ppCur)); assert((pBuf)); if (CK_U32_SOF(dwBufLen)) { return E_BAD_PARAM; } if (pdwLeft) { if (CK_U32_SOF(*pdwLeft)) { return E_BAD_PARAM; } if (*pdwLeft < sizeof(uint16_t) + dwBufLen) { return E_OVERFLOW; } } CHECK_RET(addWord(ppCur,pdwLeft, (uint16_t)dwBufLen, iNetByteOrder)); return AddBuf(ppCur, pdwLeft, pBuf, dwBufLen); }
void ScoreICMTrk(long part, double x0, double y0, double z0, double u, double v, double w, double lmax, double E, double wgt, long id) { long icm, ntot, nmu0, nmu1, nmu2, nseg, surf, type, ptr, np, in0, in1; long idx, ng, ncross, icm0, icm1, idx0, idx1, ng0, ng1; long mua, mus, mua0, mus0, mua1, mus1; long s0, s1, s2; double d, l, x, y, z, un0, vn0, wn0, un1, vn1, wn1, un2, vn2, wn2; double wgt0, wgt1, mu0, mu1, mu2; const double *params; /* Check mode */ if ((long)RDB[DATA_ICM_CALC] == NO) return; /* Get sizes */ ntot = (long)RDB[DATA_ICM_NG0]; nmu0 = (long)RDB[DATA_ICM_NMU0]; nmu1 = (long)RDB[DATA_ICM_NMU1]; nmu2 = (long)RDB[DATA_ICM_NMU2]; nseg = (long)RDB[DATA_ICM_NSEG]; /* Get pointer to few-group structure */ ptr = (long)RDB[DATA_ICM_PTR_ENE0]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); /* Get few-group index */ if ((ng = GridSearch(ptr, E)) < 0) return; /* Convert index */ ng = ntot - ng - 1; CheckValue(FUNCTION_NAME, "ng1", "", ng, 0, ntot - 1); /* Reset new data */ icm1 = -1; idx1 = -1; mua1 = -1; mus1 = -1; ng1 = -1; wgt1 = -1; /* Loop over data */ icm = (long)RDB[DATA_PTR_ICM0]; while (icm > VALID_PTR) { /* Get original particle Albedo data */ icm0 = (long)RDB[part + PARTICLE_ICM_PTR_ICM]; idx0 = (long)RDB[part + PARTICLE_ICM_IDX]; mua0 = (long)RDB[part + PARTICLE_ICM_MUA]; mus0 = (long)RDB[part + PARTICLE_ICM_MUS]; ng0 = (long)RDB[part + PARTICLE_ICM_G]; wgt0 = RDB[part + PARTICLE_ICM_WGT]; /* Get surface pointer */ surf = (long)RDB[icm + ICM_PTR_SURF]; CheckPointer(FUNCTION_NAME, "(surf)", DATA_ARRAY, surf); /* Get surface type */ type = (long)RDB[surf + SURFACE_TYPE]; /* Get number of parameters */ np = (long)RDB[surf + SURFACE_N_PARAMS]; /* Pointer to parameter list */ ptr = (long)RDB[surf + SURFACE_PTR_PARAMS]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); params = &RDB[ptr]; /* Move to starting position */ /* Toi ekstrapolointi lienee turhaa sen jälkeen kun */ /* trackin.c:tä muutettiin 14.8.2014 / 2.1.22 */ Die(FUNCTION_NAME, "HUOM!!!"); x = x0 - 2.0*EXTRAP_L*u; y = y0 - 2.0*EXTRAP_L*v; z = z0 - 2.0*EXTRAP_L*w; /* Reset total distance and number of crossings */ l = 0.0; ncross = 0; /* Get initial position */ in0 = TestSurface(surf, x, y, z, NO, id); in1 = -1; /* Loop over all surfaces in track */ while (l < lmax) { /* Get distance */ d = SurfaceDistance(surf, params, type, np, x, y, z, u, v, w, id); /* Extrapolate */ d = d + EXTRAP_L; /* Update coordinates */ x = x + d*u; y = y + d*v; z = z + d*w; /* Test position */ in1 = TestSurface(surf, x, y, z, NO, id); /* Check with maximum */ if (l + d > lmax) { /* Go back to collision site (for debugging) */ x = x0 + lmax*u; y = y0 + lmax*v; z = z0 + lmax*w; /* Cancel crossing */ in1 = in0; /* Break loop */ break; } else { /* Update distance */ l = l + d; } /* Check if surface was crossed */ if (in0 != in1) { /* Add counter */ ncross++; /* Get surface index */ if ((idx = ICMIdx(surf, x, y, z, &un0, &vn0, &wn0, &un1, &vn1, &wn1, &un2, &vn2, &wn2)) > -1) { /* Calculate cosines */ mu0 = un0*u + vn0*v + wn0*w; mu1 = un1*u + vn1*v + wn1*w; mu2 = un2*u + vn2*v + wn2*w; /* Get bins */ ptr = (long)RDB[DATA_ICM_PTR_MU0]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); s0 = SearchArray(&RDB[ptr], fabs(mu0), nmu0 + 1); CheckValue(FUNCTION_NAME, "s0", "", s0, 0, nmu0 - 1); ptr = (long)RDB[DATA_ICM_PTR_MU1]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); s1 = SearchArray(&RDB[ptr], mu1, nmu1 + 1); CheckValue(FUNCTION_NAME, "s1", "", s1, 0, nmu1 - 1); ptr = (long)RDB[DATA_ICM_PTR_MU2]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); s2 = SearchArray(&RDB[ptr], mu2, nmu2 + 1); CheckValue(FUNCTION_NAME, "s2", "", s2, 0, nmu2 - 1); /* Calculate asymmetric and symmetric part */ mua = s1; mus = s0*nmu2 + s2; /* Check direction */ if ((in0 == NO) && (in1 == YES)) { /* Check bins */ CheckValue(FUNCTION_NAME, "idx", "(1)", idx, 0, nseg - 1); CheckValue(FUNCTION_NAME, "mua", "(1)", mua, 0, nmu1 - 1); CheckValue(FUNCTION_NAME, "mus", "(1)", mus, 0, nmu0*nmu2 - 1); CheckValue(FUNCTION_NAME, "ng", "(1)", ng, 0, ntot - 1); /* Score inward current */ if (RDB[DATA_CYCLE_IDX] > RDB[DATA_CRIT_SKIP] - 1.0) { ptr = (long)RDB[icm + ICM_RES_CURR0]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); AddBuf(1.0, wgt, ptr, id, -1, idx, mua, mus, ng); } /* Put new data and reset weight */ icm0 = icm; idx0 = idx; mua0 = mua; mus0 = mus; ng0 = ng; wgt0 = 1.0; } else if ((in0 == YES) && (in1 == NO)) { /* Check active cycles */ if (RDB[DATA_CYCLE_IDX] > RDB[DATA_CRIT_SKIP] - 1.0) { /* Check index, group and angular bins */ if ((idx0 > -1) && (ng0 > -1) && (mua0 > -1) && (mus0 > -1)) { /* Check bins */ CheckValue(FUNCTION_NAME, "idx0", "(2)", idx0, 0, nseg - 1); CheckValue(FUNCTION_NAME, "mua0", "(2)", mua0, 0, nmu1 - 1); CheckValue(FUNCTION_NAME, "mus0", "(2)", mus0, 0, nmu0*nmu2 - 1); CheckValue(FUNCTION_NAME, "ng0", "(2)", ng0, 0, ntot - 1); CheckValue(FUNCTION_NAME, "idx", "(2)", idx, 0, nseg - 1); CheckValue(FUNCTION_NAME, "mua", "(2)", mua, 0, nmu1 - 1); CheckValue(FUNCTION_NAME, "mus", "(2)", mus, 0, nmu0*nmu2 - 1); /* Score outward current */ ptr = (long)RDB[icm + ICM_RES_CC1]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); AddBuf(1.0, wgt, ptr, id, -1, idx0, mua0, mus0, ng0, idx, mua, mus, ng); ptr = (long)RDB[icm + ICM_RES_CC2]; CheckPointer(FUNCTION_NAME, "(ptr)", DATA_ARRAY, ptr); AddBuf(wgt0, wgt, ptr, id, -1, idx0, mua0, mus0, ng0, idx, mua, mus, ng); } else if ((ng0 > -1) && (RDB[DATA_CYCLE_IDX] > RDB[DATA_CRIT_SKIP] + 20.0)) Warn(FUNCTION_NAME, "Problem in geometry?"); } /* Reset values */ icm0 = -1; idx0 = -1; mua0 = -1; mus0 = -1; ng0 = -1; wgt0 = 1.0; } } } /* Put previous position */ in0 = in1; } /* Check if particle is in */ if (in1 == YES) { /* Update new values */ if (icm1 > VALID_PTR) Die(FUNCTION_NAME, "Point (%E, %E, %E) is in multiple regions", x, y, z); else { icm1 = icm0; idx1 = idx0; mua1 = mua0; mus1 = mus0; ng1 = ng0; wgt1 = wgt0; } /* Check number of crossings */ if (ncross == 0) { /* Surface index cannot have changed */ if (idx0 != (long)RDB[part + PARTICLE_ICM_IDX]) Die(FUNCTION_NAME, "This is impossible"); /* No other crossings are possible, add to counter */ ptr = (long)RDB[icm + ICM_BREAK_PTR_COUNT]; CheckPointer(FUNCTION_NAME, "(ptr)", PRIVA_ARRAY, ptr); AddPrivateData(ptr, 1, id); /* Break loop */ break; } } /* Next */ icm = NextItem(icm); } /* Store values */ WDB[part + PARTICLE_ICM_PTR_ICM] = (double)icm1; WDB[part + PARTICLE_ICM_IDX] = (double)idx1; WDB[part + PARTICLE_ICM_MUA] = (double)mua1; WDB[part + PARTICLE_ICM_MUS] = (double)mus1; WDB[part + PARTICLE_ICM_G] = (double)ng1; WDB[part + PARTICLE_ICM_WGT] = wgt1; }
void PulseDet(long part, long mat, double dE, double x0, double y0, double z0, double wgt0, long id) { long det, loc0, loc1, idx, ptr, pts, hix, i; double Etot, wgt; /* Loop over detectors */ det = (long)RDB[DATA_PTR_DET0]; while (det > VALID_PTR) { /* Check type */ if (((long)RDB[det + DET_PARTICLE] != PARTICLE_TYPE_GAMMA) || ((long)RDB[det + DET_PTR_SBINS] > VALID_PTR)) { /* Next detector */ det = NextItem(det); /* Cycle loop */ continue; } /* Get pointer to response functions */ loc0 = (long)RDB[det + DET_PTR_RBINS]; CheckPointer(FUNCTION_NAME, "(loc0)", DATA_ARRAY, loc0); /* Check mt (no multiple reaction bins allowed) */ if ((long)RDB[loc0 + DET_RBIN_MT] != MT_PHOTON_PULSE_HEIGHT) { /* Next detector */ det = NextItem(det); /* Cycle loop */ continue; } /* Pointer to pulse data */ loc1 = (long)RDB[loc0 + DET_RBIN_PTR_PULSE_DATA]; CheckPointer(FUNCTION_NAME, "(loc1)", DATA_ARRAY, loc1); /* Get pointer to statistics */ pts = (long)RDB[det + DET_PTR_STAT]; CheckPointer(FUNCTION_NAME, "(pts)", DATA_ARRAY, pts); /* Check call type */ if (part == -1) { /*******************************************************************/ /***** Called after last batch *************************************/ /* Loop over OpenMP threads */ for (i = 0; i < (long)RDB[DATA_OMP_MAX_THREADS]; i++) { /* Retrieve stored energy and weight */ Etot = GetPrivateData(loc1 + DET_PULSE_EDEP, i); wgt = GetPrivateData(loc1 + DET_PULSE_WGT, i); /* Pointer to energy grid */ if ((ptr = (long)RDB[det + DET_PTR_EGRID]) < VALID_PTR) idx = 0; else { /* Grid search */ idx = GridSearch(ptr, Etot); } /* Check index */ if (idx > -1) { /* Score pulse */ AddBuf(1.0, wgt, pts, i, -1, idx, 0); } /* Reset pulse data */ PutPrivateData(loc1 + DET_PULSE_PHOTON_IDX, -1, i); PutPrivateData(loc1 + DET_PULSE_EDEP, 0.0, i); PutPrivateData(loc1 + DET_PULSE_WGT, -1.0, i); } /***************************************************************/ } else { /*******************************************************************/ /***** Called from collision point *********************************/ /* Check particle pointer */ CheckPointer(FUNCTION_NAME, "(part)", DATA_ARRAY, part); /* Check bin (this is just to check that the collision is */ /* inside the detector, the index is not relevant here). */ if (DetBin(det, mat, x0, y0, z0, -INFTY, 0.0, id) < 0) { /* Next detector */ det = NextItem(det); /* Cycle loop */ continue; } /* Get history index */ hix = (long)RDB[part + PARTICLE_HISTORY_IDX] + 1; /* Check index */ if (hix == (long)GetPrivateData(loc1 + DET_PULSE_PHOTON_IDX, id)) { /* Still same history, add to temporary storage */ AddPrivateData(loc1 + DET_PULSE_EDEP, dE, id); /* Compare weight */ if (wgt0 != GetPrivateData(loc1 + DET_PULSE_WGT, id)) Die(FUNCTION_NAME, "Mismatch in weight"); } else { /* New history, retrieve stored energy and weight */ Etot = GetPrivateData(loc1 + DET_PULSE_EDEP, id); wgt = GetPrivateData(loc1 + DET_PULSE_WGT, id); /* Pointer to energy grid */ if ((ptr = (long)RDB[det + DET_PTR_EGRID]) < VALID_PTR) idx = 0; else { /* Grid search */ idx = GridSearch(ptr, Etot); } /* Check index */ if (idx > -1) { /* Score pulse */ AddBuf(1.0, wgt, pts, id, -1, idx, 0); } /* Store new data */ PutPrivateData(loc1 + DET_PULSE_PHOTON_IDX, hix, id); PutPrivateData(loc1 + DET_PULSE_EDEP, dE, id); PutPrivateData(loc1 + DET_PULSE_WGT, wgt0, id); } /*******************************************************************/ } /* Next detector */ det = NextItem(det); } }
void FormState(int Q) { int I, S, S1, X; int qX, Q1, Q2; int A, B; State SP; Exp E, E1; IBuf = NULL; IMax = 0; STab = NULL; Ss = 0; AddState(1, &Q); for (S = 0; S < Ss; S++) { SP = &STab[S]; for (Xs = 0, S1 = 0; S1 < SP->States; S1++) PushQ(SP->SList[S1]); for (SP->Empty = 0, Is = 0, X = 0; X < Xs; X++) { qX = XStack[X]; EVALUATE: E = EquTab[qX].Value; switch (E->Tag) { case SymX: AddBuf(E->Body.Leaf, MakeExp(-1, OneX)); break; case OneX: SP->Empty = 1; break; case ZeroX: break; case OptX: Q1 = E->Body.Arg[0]; MakeExp(qX, OrX, MakeExp(-1, OneX), E->Body.Arg[0]); goto EVALUATE; case PlusX: Q1 = E->Body.Arg[0]; MakeExp(qX, AndX, Q1, MakeExp(-1, StarX, Q1)); goto EVALUATE; case StarX: Q1 = E->Body.Arg[0]; MakeExp(qX, OrX, MakeExp(-1, OneX), MakeExp(-1, PlusX, Q1)); goto EVALUATE; case OrX: Q1 = E->Body.Arg[0]; Q2 = E->Body.Arg[1]; PushQ(Q1); PushQ(Q2); break; case AndX: Q1 = E->Body.Arg[0], Q2 = E->Body.Arg[1]; E1 = EquTab[Q1].Value; switch (E1->Tag) { case SymX: AddBuf(E1->Body.Leaf, Q2); break; case OneX: EquTab[qX].Value = EquTab[Q2].Value; goto EVALUATE; case ZeroX: MakeExp(qX, ZeroX); break; case OptX: A = E1->Body.Arg[0]; MakeExp(qX, OrX, Q2, MakeExp(-1, AndX, A, Q2)); goto EVALUATE; case PlusX: A = E1->Body.Arg[0]; MakeExp(qX, AndX, A, MakeExp(-1, OrX, Q2, qX)); goto EVALUATE; case StarX: A = E1->Body.Arg[0]; MakeExp(qX, OrX, Q2, MakeExp(-1, AndX, A, qX)); goto EVALUATE; case OrX: A = E1->Body.Arg[0], B = E1->Body.Arg[1]; MakeExp(qX, OrX, MakeExp(-1, AndX, A, Q2), MakeExp(-1, AndX, B, Q2)); goto EVALUATE; case AndX: A = E1->Body.Arg[0], B = E1->Body.Arg[1]; MakeExp(qX, AndX, A, MakeExp(-1, AndX, B, Q2)); goto EVALUATE; } } } while (Xs > 0) PopQ(); SP->Shifts = Is; SP->ShList = cl_malloc(sizeof *SP->ShList * Is); for (I = 0; I < Is; I++) { int rhs_state = -1; SP->ShList[I].LHS = IBuf[I].LHS; rhs_state = AddState(IBuf[I].Size, IBuf[I].RHS); SP = &STab[S]; /* AddState() might have reallocated state table -> update pointer */ SP->ShList[I].RHS = rhs_state; } } free(IBuf); IBuf = 0; Is = IMax = 0; }
void* handle_tcp_client(void * arg) { printf("handling tcp client\n"); char *buffer = NULL; Header hdr; int received = -1; long sock = reinterpret_cast<long> (arg); /* Receive message */ do { if ((received = recv(sock, &hdr, sizeof(Header), 0)) < 0) { printf("handle_tcp_client: no header"); break; } printf("received = %d\n", received); if (received == 0) break; while (received < sizeof(Header)) { int next_rec; if ((next_rec = recv(sock, (char*) &hdr + received, sizeof(Header) - received, 0)) <= 0) { break; } else { usleep(100); } received += next_rec; printf("received part = %d\n", next_rec); } if (received < sizeof(Header)) break; for (int i=0; i < received; i++) printf("%02x ", (reinterpret_cast<char*> (&hdr))[i]); printf("\n"); hdr.cookie = ntohs(hdr.cookie); hdr.id = ntohs(hdr.id); hdr.cmd = ntohs(hdr.cmd); hdr.len = ntohs(hdr.len); hdr.seq = ntohl(hdr.seq); printf("cookie=%x id=%d cmd=%d len=%d seq=%ld\n", hdr.cookie, hdr.id, hdr.cmd, (hdr.len), (hdr.seq)) ; if ((hdr.id == 0 && hdr.cookie == OK_COOKIE) || (hdr.id < MAX_ID && hdr.cookie == session[hdr.id].cookie)) { printf("OK\n"); if (hdr.len > 0) { buffer = (char*) malloc(hdr.len); if (buffer == NULL) { printf("out of memory\n"); break; } for (received = 0; received < hdr.len; ) { int next_rec = recv(sock, buffer + received, hdr.len - received, 0); if (next_rec < 0) { printf("couldn't get all buffer\n"); break; } received += next_rec; } if (received < hdr.len) break; printf("got payload\n"); } if ((Cmds) hdr.cmd == E_STORE) { printf("adding len=%d\n", hdr.len); if (AddBuf(hdr.id, hdr.seq, buffer, hdr.len)) { free(buffer); } buffer = NULL; } else if ((Cmds) hdr.cmd == E_GET) { printf("E_GET\n"); if (buffer) { free(buffer); buffer = NULL; } if (SendBuf(hdr.id, hdr.seq, sock)) break; } else if ((Cmds) hdr.cmd == E_STATUS) { if (hdr.len != sizeof(BUF_Status)) { printf("hdr.len != sizeof(BUF_Status)\n"); } else { printf("E_STATUS\n"); BUF_Status* status = (BUF_Status*) buffer; session[hdr.id].alert = ntohs(status->alert); session[hdr.id].last_access = time(NULL); } if (buffer != NULL) { free(buffer); buffer = NULL; } } else if ((Cmds) hdr.cmd == E_CHECK) { Response r; BUF_R_Check c; printf("E_CHECK\n"); time_t now = time(NULL); r.response = htons(E_R_CHECK); r.len = htons(sizeof(BUF_R_Check)); c.alert = htons(session[hdr.id].alert); c.last_access_sec = htons((int) difftime(now, session[hdr.id].last_access)); if (send(sock, &r, sizeof(r), 0) != sizeof(r)) break; if (send(sock, &c, sizeof(c), 0) != sizeof(c)) break; } else if ((Cmds) hdr.cmd == E_CREATE) { Response r; BUF_R_Create_Login c; time_t now = time(NULL); printf("E_CREATE\n"); if (hdr.len != sizeof(BUF_Create_Login)) { printf("hdr.len != sizeof(BUF_Create_Login)\n"); } else { BUF_Create_Login* status = (BUF_Create_Login*) buffer; char username[MAX_NAME_LEN]; char password[MAX_NAME_LEN]; strncpy(username, status->username, MAX_NAME_LEN); strncpy(password, status->password, MAX_NAME_LEN); username[MAX_NAME_LEN-1] = 0; password[MAX_NAME_LEN-1] = 0; bool done = false; for (int i = 0; i < MAX_ID; i++) { if (users[i].username[0] == 0 || !strcmp(users[i].username, username) || difftime(now, users[i].last_access) > 60*60*24) { strcpy(users[i].password, password); users[i].last_access = time(NULL); pthread_mutex_lock(&g_mutex); while (session[next_id].last_access != 0 && difftime(now, session[next_id].last_access) < 60) { next_id = (next_id + 1) & MAX_ID; usleep(1000); now = time(NULL); } int id = next_id; next_id = (next_id + 1) % MAX_ID; pthread_mutex_unlock(&g_mutex); pthread_mutex_lock(&session[next_id].mutex); for (int i = 0; i < MAX_BUFS; i++) if (session[id].buf[i] != NULL) { free(session[id].buf); session[id].buf[i] = NULL; } session[id].alert = 0; session[id].head = 0; session[id].tail = 0; session[id].last_access = time(NULL); session[id].cookie = (unsigned short) time(NULL); pthread_mutex_unlock(&session[id].mutex); Response r; BUF_R_Create_Login c; r.response = htons(E_R_CREATE); r.len = htons(sizeof(BUF_R_Create_Login)); c.id = htons(id); c.cookie = htons(session[id].cookie); done = true; if (send(sock, &r, sizeof(r), 0) != sizeof(r)) break; if (send(sock, &c, sizeof(c), 0) != sizeof(c)) break; break; } } if (!done) { Response r; BUF_R_Create_Login c; r.response = htons(E_R_CREATE); r.len = htons(sizeof(BUF_R_Create_Login)); c.id = htons(0xFFFF); c.cookie = htons(0xFFFF); if (send(sock, &r, sizeof(r), 0) != sizeof(r)) break; if (send(sock, &c, sizeof(c), 0) != sizeof(c)) break; } } } else if ((Cmds) hdr.cmd == E_LOGIN) { Response r; BUF_R_Create_Login c; printf("E_LOGIN"); if (hdr.len != sizeof(BUF_Create_Login)) { printf("hdr.len != sizeof(BUF_Create_Login)\n"); } else { BUF_Create_Login* status = (BUF_Create_Login*) buffer; char username[MAX_NAME_LEN]; char password[MAX_NAME_LEN]; strncpy(username, status->username, MAX_NAME_LEN); strncpy(password, status->password, MAX_NAME_LEN); username[MAX_NAME_LEN-1] = 0; password[MAX_NAME_LEN-1] = 0; printf("username=%s, password=%d\n", username, password); bool done = false; Response r; BUF_R_Create_Login c; r.response = htons(E_R_LOGIN); r.len = htons(sizeof(BUF_R_Create_Login)); c.id = htons(0xFFFF); c.cookie = htons(0xFFFF); for (int i = 0; i < MAX_ID; i++) { if (!strcmp(users[i].username, username)) { if (!strcmp(users[i].password, password)) { c.id = htons(users[i].id); c.cookie = htons(users[i].cookie); printf("found login\n"); break; } else { printf("username ok password not=%s\n", users[i].password); } } else { printf("not username=%s\n", users[i].username); } } if (send(sock, &r, sizeof(r), 0) != sizeof(r)) break; if (send(sock, &c, sizeof(c), 0) != sizeof(c)) break; } } else { printf("Unknown command\n"); if (buffer) { free(buffer); buffer = NULL; } } } } while (1); close(sock); if (buffer != NULL) { free(buffer); buffer = NULL; } printf("client closed\n"); pthread_exit( NULL ); }
void ScoreInterfacePower(double fissE, double wgt, double x, double y, double z, double t, long id) { long loc0, loc1, ptr, ncol, idx, nz, nr, i, j, k, uni, na, nt, l; double zmin, zmax, x0, y0, r0, r, f, r2, phi; /* Check that interfaces are defined */ if ((loc0 = (long)RDB[DATA_PTR_IFC0]) < VALID_PTR) return; /***************************************************************************/ /***** Interface to thermal hydraulics *************************************/ /* Get zone index */ ptr = (long)RDB[DATA_PTR_ZONE_IDX]; idx = (long)GetPrivateData(ptr, id); /* Loop over interfaces */ while (loc0 > VALID_PTR) { /* Check flag and type */ if (((long)RDB[loc0 + IFC_CALC_OUTPUT] == YES) && (((long)RDB[loc0 + IFC_TYPE] < IFC_TYPE_FUEP) || ((long)RDB[loc0 + IFC_TYPE] > IFC_TYPE_FPIP))) { /* Get pointer to statistics */ ptr = (long)RDB[loc0 + IFC_PTR_STAT]; CheckPointer(FUNCTION_NAME, "ptr", DATA_ARRAY, ptr); /* Check type */ if ((long)RDB[loc0 + IFC_TYPE] == IFC_TYPE_TET_MESH) { /* Get collision number */ ncol = (long)RDB[DATA_PTR_COLLISION_COUNT]; ncol = (long)GetPrivateData(ncol, id); /* Get pointer to tet cell (set in ifcpoint.c) */ if ((loc1 = TestValuePair(loc0 + IFC_PTR_PREV_COL_CELL, ncol, id)) > VALID_PTR) { /* Get index to statistics and score */ if ((i = (long)RDB[loc1 + IFC_TET_MSH_STAT_IDX]) > -1) AddBuf1D(fissE, wgt, ptr, id, i); } } else { /* Other types, get axial boundaries and number of bins */ zmin = RDB[loc0 + IFC_ZMIN]; zmax = RDB[loc0 + IFC_ZMAX]; nz = (long)RDB[loc0 + IFC_NZ]; nr = (long)RDB[loc0 + IFC_NR]; /* Find region (toi z-tarkistus tarvitaan että indeksi menee */ /* alarajalla oikein) */ if ((z >= zmin) && (z < zmax)) if ((loc1 = (long)RDB[loc0 + IFC_PTR_SCORE]) > VALID_PTR) if ((loc1 = SeekList(loc1, IFC_SCORE_REG_IDX, idx, SORT_MODE_ASCEND)) > VALID_PTR) { /* Get stat index */ i = (long)RDB[loc1 + IFC_SCORE_STAT_IDX]; CheckValue(FUNCTION_NAME, "i", "", i, 0, (long)RDB[loc0 + IFC_STAT_NREG]); /* Get pointer to output data */ loc1 = (long)RDB[loc1 + IFC_SCORE_PTR_OUT]; CheckPointer(FUNCTION_NAME, "(loc1)", DATA_ARRAY, loc1); /* Calculate axial bin */ j = (long)((z - zmin)/(zmax - zmin)*((double)nz)); CheckValue(FUNCTION_NAME, "j", "", j, 0, nz - 1); /* Get center coordinates and radius */ x0 = RDB[loc1 + IFC_OUT_X0]; y0 = RDB[loc1 + IFC_OUT_Y0]; r0 = RDB[loc1 + IFC_OUT_R]; /* Check for zero radius */ if (r0 < ZERO) Die(FUNCTION_NAME, "Zero radius"); /* Get square radius */ r = (x - x0)*(x - x0) + (y - y0)*(y - y0); /* Calculate radial zone (typerä toi jälkimmäinen) */ if ((f = r/r0/r0) > 1.0) Die(FUNCTION_NAME, "Point is not inside %E %E : %E %E : %E", x, y, x0, y0, r0); else if (f == 1.0) f = 0.999999; /* Index */ k = (long)(f*nr); CheckValue(FUNCTION_NAME, "k", "", k, 0, nr - 1); /* Score */ AddBuf(fissE, wgt, ptr, id, -1, i, j, k); } } } /* Next interface */ loc0 = NextItem(loc0); } /***************************************************************************/ /***** Interface to fuel performance codes *********************************/ /* Get collision universe */ ptr = (long)RDB[DATA_PTR_COLLISION_UNI]; uni = GetPrivateData(ptr, id); /* Check pointer */ CheckPointer(FUNCTION_NAME, "(uni)", DATA_ARRAY, uni); /* Check pointer to interface */ if ((loc1 = (long)RDB[uni + UNIVERSE_PTR_IFC_FUEP]) > VALID_PTR) { /* Get coordinates */ ptr = RDB[uni + UNIVERSE_PTR_PRIVA_X]; CheckPointer(FUNCTION_NAME, "(xptr)", PRIVA_ARRAY, ptr); x = GetPrivateData(ptr, id); ptr = RDB[uni + UNIVERSE_PTR_PRIVA_Y]; CheckPointer(FUNCTION_NAME, "(yptr)", PRIVA_ARRAY, ptr); y = GetPrivateData(ptr, id); ptr = RDB[uni + UNIVERSE_PTR_PRIVA_Z]; CheckPointer(FUNCTION_NAME, "(zptr)", PRIVA_ARRAY, ptr); z = GetPrivateData(ptr, id); ptr = RDB[uni + UNIVERSE_PTR_PRIVA_T]; CheckPointer(FUNCTION_NAME, "(ptr)", PRIVA_ARRAY, ptr); t = GetPrivateData(ptr, id); /* Coordinate transformation to cold system */ CoordExpans(loc1, &x, &y, &z, t, 1); /* Get the size of the statistics */ ptr = (long)RDB[loc1 + IFC_FUEP_OUT_PTR_LIM]; CheckPointer(FUNCTION_NAME, "(limptr)", DATA_ARRAY, ptr); nz = (long)RDB[ptr + FUEP_NZ]; na = (long)RDB[ptr + FUEP_NA]; nr = (long)RDB[ptr + FUEP_NR]; nt = (long)RDB[ptr + FUEP_NT]; /* Get pointer to axial output zones */ ptr = (long)RDB[loc1 + IFC_FUEP_OUT_PTR_Z]; CheckPointer(FUNCTION_NAME, "(zptr)", DATA_ARRAY, ptr); /* Find interval */ i = SearchArray(&RDB[ptr], z, nz + 1); /* Check */ if (i < 0) { Warn(FUNCTION_NAME,"Outside of axial zone"); return; } /* Calculate angle */ phi = PolarAngle(x, y); /* Check phi */ CheckValue(FUNCTION_NAME, "phi", "", phi, 0.0, 2.0*PI); /* Get pointer to angular output zones */ ptr = (long)RDB[loc1 + IFC_FUEP_OUT_PTR_PHI]; CheckPointer(FUNCTION_NAME, "(aptr)", DATA_ARRAY, ptr); /* Rotate if needed */ if (phi > 2.0*PI+RDB[ptr]) phi -= 2.0*PI; /* Find interval */ j = SearchArray(&RDB[ptr], phi, na + 1); /* Check */ if (j < 0) { Warn(FUNCTION_NAME,"Outside of angular zone"); return; } /* Calculate square radius */ r2 = x*x + y*y; /* Get pointer to radial output zones */ ptr = (long)RDB[loc1 + IFC_FUEP_OUT_PTR_R2]; CheckPointer(FUNCTION_NAME, "(rptr)", DATA_ARRAY, ptr); /* Find interval */ k = SearchArray(&RDB[ptr], r2, nr + 1); /* Check */ if (k < 0) { Warn(FUNCTION_NAME,"Outside of radial zone"); return; } /* Find time bin */ ptr = (long)RDB[loc1 + IFC_FUEP_OUT_PTR_TB]; CheckPointer(FUNCTION_NAME, "(TBptr)", DATA_ARRAY, ptr); /* Find bin*/ l = SearchArray(&RDB[ptr], t, nt + 1); /* Check */ if (l < 0) return; /* Score */ ptr = (long)RDB[loc1 + IFC_FUEP_PTR_POWER]; CheckPointer(FUNCTION_NAME, "(Pptr)", DATA_ARRAY, ptr); AddBuf(fissE, wgt, ptr, id, -1, i, j, k, l); } /***************************************************************************/ }
void ApplyGCSymmetries(long gcu) { long ng, adf, ptr, surf, type, ns, nc, nmax, n, m, i, sym, mode; double *f, *f0, val, max; /* Check pointer to group constant universe */ CheckPointer(FUNCTION_NAME, "(gcu)", DATA_ARRAY, gcu); /***************************************************************************/ /***** Fluxes and currents in ADF's ****************************************/ /* Reset maximum difference */ max = 0.0; /* Get pointer to ADF structure and symmetry */ if ((adf = (long)RDB[gcu + GCU_PTR_ADF]) > VALID_PTR) if ((sym = (long)RDB[adf + ADF_SYM]) > 0) { /* Get pointer to outer boundary surface */ surf = (long)RDB[adf + ADF_PTR_SURF]; CheckPointer(FUNCTION_NAME, "(surf)", DATA_ARRAY, surf); /* Get surface type */ type = (long)RDB[surf + SURFACE_TYPE]; /* Get number of surfaces and corners */ ns = (long)RDB[adf + ADF_NSURF]; CheckValue(FUNCTION_NAME, "ns", "", ns, 1, 6); nc = (long)RDB[adf + ADF_NCORN]; CheckValue(FUNCTION_NAME, "nc", "", nc, 0, 6); /* Get number of energy groups */ ng = (long)RDB[DATA_ERG_FG_NG]; CheckValue(FUNCTION_NAME, "ng", "", ng, 1, 100000); /* Allocate memory for temporary arrays */ if (ns > nc) { f0 = (double *)Mem(MEM_ALLOC, ns, sizeof(double)); f = (double *)Mem(MEM_ALLOC, ns, sizeof(double)); } else { f0 = (double *)Mem(MEM_ALLOC, nc, sizeof(double)); f = (double *)Mem(MEM_ALLOC, nc, sizeof(double)); } /* Loop over parameters */ for (i = 0; i < 11; i++) { /* Avoid compiler warning */ ptr = -1; nmax = 0; mode = 0; /* Get pointer and set number of values */ if (i == 0) { ptr = RDB[gcu + GCU_RES_FG_DF_HET_SURF_FLUX]; nmax = ns; mode = 1; } else if (i == 1) { ptr = RDB[gcu + GCU_RES_FG_DF_HET_CORN_FLUX]; nmax = nc; mode = 2; } else if (i == 2) { ptr = RDB[gcu + GCU_RES_FG_DF_SURF_IN_CURR]; nmax = ns; mode = 1; } else if (i == 3) { ptr = RDB[gcu + GCU_RES_FG_DF_SURF_OUT_CURR]; nmax = ns; mode = 1; } else if (i == 4) { ptr = RDB[gcu + GCU_RES_FG_DF_SURF_NET_CURR]; nmax = ns; mode = 1; } else if (i == 5) { ptr = RDB[gcu + GCU_RES_FG_DF_MID_IN_CURR]; nmax = ns; mode = 1; } else if (i == 6) { ptr = RDB[gcu + GCU_RES_FG_DF_MID_OUT_CURR]; nmax = ns; mode = 1; } else if (i == 7) { ptr = RDB[gcu + GCU_RES_FG_DF_MID_NET_CURR]; nmax = ns; mode = 1; } else if (i == 8) { ptr = RDB[gcu + GCU_RES_FG_DF_CORN_IN_CURR]; nmax = nc; mode = 2; } else if (i == 9) { ptr = RDB[gcu + GCU_RES_FG_DF_CORN_OUT_CURR]; nmax = nc; mode = 2; } else if (i == 10) { ptr = RDB[gcu + GCU_RES_FG_DF_CORN_NET_CURR]; nmax = nc; mode = 2; } else Die(FUNCTION_NAME, "Overflow"); /* Check pointer */ if (ptr < VALID_PTR) continue; /* Loop over energy groups */ for (n = 0; n < ng; n++) { /* Read data */ for (m = 0; m < nmax; m++) f0[m] = BufVal(ptr, m, n); /* Check geometry type */ switch (type) { case SURF_SQC: case SURF_RECT: { /* Infinite square prism (2D case) */ if (sym == 1) { /* Full symmetry */ if (type == SURF_SQC) { /* Average over all values if sqc */ val = (f0[0] + f0[1] + f0[2] + f0[3])/4.0; f[0] = val - f0[0]; f[1] = val - f0[1]; f[2] = val - f0[2]; f[3] = val - f0[3]; } else { /* Average over NS and EW and all corners */ /* if rect */ if (mode == 1) { val = (f0[S] + f0[N])/2.0; f[S] = val - f0[S]; f[N] = val - f0[N]; val = (f0[W] + f0[E])/2.0; f[W] = val - f0[W]; f[E] = val - f0[E]; } else { val = (f0[0] + f0[1] + f0[2] + f0[3])/4.0; f[0] = val - f0[0]; f[1] = val - f0[1]; f[2] = val - f0[2]; f[3] = val - f0[3]; } } } else if (sym == 2) { /* S1 / NS symmetry */ if (mode == 1) { val = (f0[S] + f0[N])/2.0; f[W] = 0.0; f[S] = val - f0[S]; f[E] = 0.0; f[N] = val - f0[N]; } else { val = (f0[NW] + f0[SW])/2.0; f[NW] = val - f0[NW]; f[SW] = val - f0[SW]; val = (f0[NE] + f0[SE])/2.0; f[NE] = val - f0[NE]; f[SE] = val - f0[SE]; } } else if (sym == 3) { /* C1 / SENW symmetry */ if (mode == 1) { val = (f0[W] + f0[S])/2.0; f[W] = val - f0[W]; f[S] = val - f0[S]; val = (f0[E] + f0[N])/2.0; f[E] = val - f0[E]; f[N] = val - f0[N]; } else { val = (f0[SE] + f0[NW])/2.0; f[SW] = 0.0; f[SE] = val - f0[SE]; f[NW] = val - f0[NW]; f[NE] = 0.0; } } else if (sym == 4) { /* S2 / EW symmetry */ if (mode == 1) { val = (f0[W] + f0[E])/2.0; f[W] = val - f0[W]; f[S] = 0.0; f[E] = val - f0[E]; f[N] = 0.0; } else { val = (f0[SW] + f0[SE])/2.0; f[SW] = val - f0[SW]; f[SE] = val - f0[SE]; val = (f0[NW] + f0[NE])/2.0; f[NW] = val - f0[NW]; f[NE] = val - f0[NE]; } } else if (sym == 5) { /* C2 / SWNE symmetry */ if (mode == 1) { val = (f0[W] + f0[N])/2.0; f[W] = val - f0[W]; f[N] = val - f0[N]; val = (f0[E] + f0[S])/2.0; f[E] = val - f0[E]; f[S] = val - f0[S]; } else { val = (f0[SW] + f0[NE])/2.0; f[SW] = val - f0[SW]; f[SE] = 0.0; f[NW] = 0.0; f[NE] = val - f0[NE]; } } else if (sym != 0) Die(FUNCTION_NAME, "Invalid symmetry"); /* Break case */ break; } case SURF_HEXYC: case SURF_HEXXC: { /* Infinite hexagonal prism (2D case) */ if (sym == 1) { /* Full symmetry */ val = (f0[0] + f0[1] + f0[2] + f0[3] + f0[4] + f0[5])/6.0; f[0] = val - f0[0]; f[1] = val - f0[1]; f[2] = val - f0[2]; f[3] = val - f0[3]; f[4] = val - f0[4]; f[5] = val - f0[5]; } else if (sym == 2) { /* S1-symmetry */ if (mode == 1) { f[0] = 0.0; f[3] = 0.0; val = (f0[1] + f0[5])/2.0; f[1] = val - f0[1]; f[5] = val - f0[5]; val = (f0[2] + f0[4])/2.0; f[2] = val - f0[2]; f[4] = val - f0[4]; } else { val = (f0[0] + f0[5])/2.0; f[0] = val - f0[0]; f[5] = val - f0[5]; val = (f0[1] + f0[4])/2.0; f[1] = val - f0[1]; f[4] = val - f0[4]; val = (f0[2] + f0[3])/2.0; f[2] = val - f0[2]; f[3] = val - f0[3]; } } else if (sym == 3) { /* C1-symmetry */ if (mode == 1) { val = (f0[0] + f0[1])/2.0; f[0] = val - f0[0]; f[1] = val - f0[1]; val = (f0[2] + f0[5])/2.0; f[2] = val - f0[2]; f[5] = val - f0[5]; val = (f0[3] + f0[4])/2.0; f[3] = val - f0[3]; f[4] = val - f0[4]; } else { f[0] = 0.0; f[3] = 0.0; val = (f0[1] + f0[5])/2.0; f[1] = val - f0[1]; f[5] = val - f0[5]; val = (f0[2] + f0[4])/2.0; f[2] = val - f0[2]; f[4] = val - f0[4]; } } else if (sym == 4) { /* S2-symmetry */ if (mode == 1) { f[1] = 0.0; f[4] = 0.0; val = (f0[0] + f0[2])/2.0; f[0] = val - f0[0]; f[2] = val - f0[2]; val = (f0[3] + f0[5])/2.0; f[3] = val - f0[3]; f[5] = val - f0[5]; } else { val = (f0[0] + f0[1])/2.0; f[0] = val - f0[0]; f[1] = val - f0[1]; val = (f0[2] + f0[5])/2.0; f[2] = val - f0[2]; f[5] = val - f0[5]; val = (f0[3] + f0[4])/2.0; f[3] = val - f0[3]; f[4] = val - f0[4]; } } else if (sym == 5) { /* C2-symmetry */ if (mode == 1) { val = (f0[0] + f0[3])/2.0; f[0] = val - f0[0]; f[3] = val - f0[3]; val = (f0[1] + f0[2])/2.0; f[1] = val - f0[1]; f[2] = val - f0[2]; val = (f0[4] + f0[5])/2.0; f[4] = val - f0[4]; f[5] = val - f0[5]; } else { f[1] = 0.0; f[4] = 0.0; val = (f0[0] + f0[2])/2.0; f[0] = val - f0[0]; f[2] = val - f0[2]; val = (f0[3] + f0[5])/2.0; f[3] = val - f0[3]; f[5] = val - f0[5]; } } else if (sym == 6) { /* S3-symmetry */ if (mode == 1) { f[2] = 0.0; f[5] = 0.0; val = (f0[1] + f0[3])/2.0; f[1] = val - f0[1]; f[3] = val - f0[3]; val = (f0[0] + f0[4])/2.0; f[0] = val - f0[0]; f[4] = val - f0[4]; } else { val = (f0[0] + f0[3])/2.0; f[0] = val - f0[0]; f[3] = val - f0[3]; val = (f0[1] + f0[2])/2.0; f[1] = val - f0[1]; f[2] = val - f0[2]; val = (f0[4] + f0[5])/2.0; f[4] = val - f0[4]; f[5] = val - f0[5]; } } else if (sym == 7) { /* C3-symmetry */ if (mode == 1) { val = (f0[0] + f0[5])/2.0; f[0] = val - f0[0]; f[5] = val - f0[5]; val = (f0[1] + f0[4])/2.0; f[1] = val - f0[1]; f[4] = val - f0[4]; val = (f0[2] + f0[3])/2.0; f[2] = val - f0[2]; f[3] = val - f0[3]; } else { f[2] = 0.0; f[5] = 0.0; val = (f0[1] + f0[3])/2.0; f[1] = val - f0[1]; f[3] = val - f0[3]; val = (f0[0] + f0[4])/2.0; f[0] = val - f0[0]; f[4] = val - f0[4]; } } else if (sym != 0) Die(FUNCTION_NAME, "Invalid symmetry"); /* Break case */ break; } } /* Mark scoring buffer unreduced */ WDB[DATA_BUF_REDUCED] = (double)NO; /* Get maximum difference for error checking */ /* (surface flux and currents) */ if ((i == 0) || (i == 2) || (i == 3)) for (m = 0; m < nmax; m++) if (fabs(f[m]/f0[m]) > max) max = fabs(f[m]/f0[m]); /* Put data */ for (m = 0; m < nmax; m++) AddBuf(f[m], 1.0, ptr, 0, -1, m, n); /* Reduce buffer */ ReduceBuffer(); } } /* Free temporary arrays */ Mem(MEM_FREE, f0); Mem(MEM_FREE, f); } /* Print warning if statistics is good enough */ if ((long)(RDB[DATA_MICRO_CALC_BATCH_SIZE]*RDB[DATA_CYCLE_BATCH_SIZE]) > 1000*20) if (max > 0.1) Note(0, "ADF symmetry option may be wrong"); /***************************************************************************/ }