double do_tpi(FILE *fplog, t_commrec *cr, int nfile, const t_filenm fnm[], const output_env_t oenv, gmx_bool bVerbose, gmx_bool gmx_unused bCompact, int gmx_unused nstglobalcomm, gmx_vsite_t gmx_unused *vsite, gmx_constr_t gmx_unused constr, int gmx_unused stepout, t_inputrec *inputrec, gmx_mtop_t *top_global, t_fcdata *fcd, t_state *state, t_mdatoms *mdatoms, t_nrnb *nrnb, gmx_wallcycle_t wcycle, gmx_edsam_t gmx_unused ed, t_forcerec *fr, int gmx_unused repl_ex_nst, int gmx_unused repl_ex_nex, int gmx_unused repl_ex_seed, gmx_membed_t gmx_unused membed, real gmx_unused cpt_period, real gmx_unused max_hours, const char gmx_unused *deviceOptions, int gmx_unused imdport, unsigned long gmx_unused Flags, gmx_walltime_accounting_t walltime_accounting) { const char *TPI = "Test Particle Insertion"; gmx_localtop_t *top; gmx_groups_t *groups; gmx_enerdata_t *enerd; rvec *f; real lambda, t, temp, beta, drmax, epot; double embU, sum_embU, *sum_UgembU, V, V_all, VembU_all; t_trxstatus *status; t_trxframe rerun_fr; gmx_bool bDispCorr, bCharge, bRFExcl, bNotLastFrame, bStateChanged, bNS; tensor force_vir, shake_vir, vir, pres; int cg_tp, a_tp0, a_tp1, ngid, gid_tp, nener, e; rvec *x_mol; rvec mu_tot, x_init, dx, x_tp; int nnodes, frame; gmx_int64_t frame_step_prev, frame_step; gmx_int64_t nsteps, stepblocksize = 0, step; gmx_int64_t rnd_count_stride, rnd_count; gmx_int64_t seed; double rnd[4]; int i, start, end; FILE *fp_tpi = NULL; char *ptr, *dump_pdb, **leg, str[STRLEN], str2[STRLEN]; double dbl, dump_ener; gmx_bool bCavity; int nat_cavity = 0, d; real *mass_cavity = NULL, mass_tot; int nbin; double invbinw, *bin, refvolshift, logV, bUlogV; real dvdl, prescorr, enercorr, dvdlcorr; gmx_bool bEnergyOutOfBounds; const char *tpid_leg[2] = {"direct", "reweighted"}; /* Since there is no upper limit to the insertion energies, * we need to set an upper limit for the distribution output. */ real bU_bin_limit = 50; real bU_logV_bin_limit = bU_bin_limit + 10; nnodes = cr->nnodes; top = gmx_mtop_generate_local_top(top_global, inputrec); groups = &top_global->groups; bCavity = (inputrec->eI == eiTPIC); if (bCavity) { ptr = getenv("GMX_TPIC_MASSES"); if (ptr == NULL) { nat_cavity = 1; } else { /* Read (multiple) masses from env var GMX_TPIC_MASSES, * The center of mass of the last atoms is then used for TPIC. */ nat_cavity = 0; while (sscanf(ptr, "%lf%n", &dbl, &i) > 0) { srenew(mass_cavity, nat_cavity+1); mass_cavity[nat_cavity] = dbl; fprintf(fplog, "mass[%d] = %f\n", nat_cavity+1, mass_cavity[nat_cavity]); nat_cavity++; ptr += i; } if (nat_cavity == 0) { gmx_fatal(FARGS, "Found %d masses in GMX_TPIC_MASSES", nat_cavity); } } } /* init_em(fplog,TPI,inputrec,&lambda,nrnb,mu_tot, state->box,fr,mdatoms,top,cr,nfile,fnm,NULL,NULL);*/ /* We never need full pbc for TPI */ fr->ePBC = epbcXYZ; /* Determine the temperature for the Boltzmann weighting */ temp = inputrec->opts.ref_t[0]; if (fplog) { for (i = 1; (i < inputrec->opts.ngtc); i++) { if (inputrec->opts.ref_t[i] != temp) { fprintf(fplog, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n"); fprintf(stderr, "\nWARNING: The temperatures of the different temperature coupling groups are not identical\n\n"); } } fprintf(fplog, "\n The temperature for test particle insertion is %.3f K\n\n", temp); } beta = 1.0/(BOLTZ*temp); /* Number of insertions per frame */ nsteps = inputrec->nsteps; /* Use the same neighborlist with more insertions points * in a sphere of radius drmax around the initial point */ /* This should be a proper mdp parameter */ drmax = inputrec->rtpi; /* An environment variable can be set to dump all configurations * to pdb with an insertion energy <= this value. */ dump_pdb = getenv("GMX_TPI_DUMP"); dump_ener = 0; if (dump_pdb) { sscanf(dump_pdb, "%lf", &dump_ener); } atoms2md(top_global, inputrec, 0, NULL, top_global->natoms, mdatoms); update_mdatoms(mdatoms, inputrec->fepvals->init_lambda); snew(enerd, 1); init_enerdata(groups->grps[egcENER].nr, inputrec->fepvals->n_lambda, enerd); snew(f, top_global->natoms); /* Print to log file */ walltime_accounting_start(walltime_accounting); wallcycle_start(wcycle, ewcRUN); print_start(fplog, cr, walltime_accounting, "Test Particle Insertion"); /* The last charge group is the group to be inserted */ cg_tp = top->cgs.nr - 1; a_tp0 = top->cgs.index[cg_tp]; a_tp1 = top->cgs.index[cg_tp+1]; if (debug) { fprintf(debug, "TPI cg %d, atoms %d-%d\n", cg_tp, a_tp0, a_tp1); } if (a_tp1 - a_tp0 > 1 && (inputrec->rlist < inputrec->rcoulomb || inputrec->rlist < inputrec->rvdw)) { gmx_fatal(FARGS, "Can not do TPI for multi-atom molecule with a twin-range cut-off"); } snew(x_mol, a_tp1-a_tp0); bDispCorr = (inputrec->eDispCorr != edispcNO); bCharge = FALSE; for (i = a_tp0; i < a_tp1; i++) { /* Copy the coordinates of the molecule to be insterted */ copy_rvec(state->x[i], x_mol[i-a_tp0]); /* Check if we need to print electrostatic energies */ bCharge |= (mdatoms->chargeA[i] != 0 || (mdatoms->chargeB && mdatoms->chargeB[i] != 0)); } bRFExcl = (bCharge && EEL_RF(fr->eeltype) && fr->eeltype != eelRF_NEC); calc_cgcm(fplog, cg_tp, cg_tp+1, &(top->cgs), state->x, fr->cg_cm); if (bCavity) { if (norm(fr->cg_cm[cg_tp]) > 0.5*inputrec->rlist && fplog) { fprintf(fplog, "WARNING: Your TPI molecule is not centered at 0,0,0\n"); fprintf(stderr, "WARNING: Your TPI molecule is not centered at 0,0,0\n"); } } else { /* Center the molecule to be inserted at zero */ for (i = 0; i < a_tp1-a_tp0; i++) { rvec_dec(x_mol[i], fr->cg_cm[cg_tp]); } } if (fplog) { fprintf(fplog, "\nWill insert %d atoms %s partial charges\n", a_tp1-a_tp0, bCharge ? "with" : "without"); fprintf(fplog, "\nWill insert %d times in each frame of %s\n", (int)nsteps, opt2fn("-rerun", nfile, fnm)); } if (!bCavity) { if (inputrec->nstlist > 1) { if (drmax == 0 && a_tp1-a_tp0 == 1) { gmx_fatal(FARGS, "Re-using the neighborlist %d times for insertions of a single atom in a sphere of radius %f does not make sense", inputrec->nstlist, drmax); } if (fplog) { fprintf(fplog, "Will use the same neighborlist for %d insertions in a sphere of radius %f\n", inputrec->nstlist, drmax); } } } else { if (fplog) { fprintf(fplog, "Will insert randomly in a sphere of radius %f around the center of the cavity\n", drmax); } } ngid = groups->grps[egcENER].nr; gid_tp = GET_CGINFO_GID(fr->cginfo[cg_tp]); nener = 1 + ngid; if (bDispCorr) { nener += 1; } if (bCharge) { nener += ngid; if (bRFExcl) { nener += 1; } if (EEL_FULL(fr->eeltype)) { nener += 1; } } snew(sum_UgembU, nener); /* Copy the random seed set by the user */ seed = inputrec->ld_seed; /* We use the frame step number as one random counter. * The second counter use the insertion (step) count. But we * need multiple random numbers per insertion. This number is * not fixed, since we generate random locations in a sphere * by putting locations in a cube and some of these fail. * A count of 20 is already extremely unlikely, so 10000 is * a safe margin for random numbers per insertion. */ rnd_count_stride = 10000; if (MASTER(cr)) { fp_tpi = xvgropen(opt2fn("-tpi", nfile, fnm), "TPI energies", "Time (ps)", "(kJ mol\\S-1\\N) / (nm\\S3\\N)", oenv); xvgr_subtitle(fp_tpi, "f. are averages over one frame", oenv); snew(leg, 4+nener); e = 0; sprintf(str, "-kT log(<Ve\\S-\\betaU\\N>/<V>)"); leg[e++] = strdup(str); sprintf(str, "f. -kT log<e\\S-\\betaU\\N>"); leg[e++] = strdup(str); sprintf(str, "f. <e\\S-\\betaU\\N>"); leg[e++] = strdup(str); sprintf(str, "f. V"); leg[e++] = strdup(str); sprintf(str, "f. <Ue\\S-\\betaU\\N>"); leg[e++] = strdup(str); for (i = 0; i < ngid; i++) { sprintf(str, "f. <U\\sVdW %s\\Ne\\S-\\betaU\\N>", *(groups->grpname[groups->grps[egcENER].nm_ind[i]])); leg[e++] = strdup(str); } if (bDispCorr) { sprintf(str, "f. <U\\sdisp c\\Ne\\S-\\betaU\\N>"); leg[e++] = strdup(str); } if (bCharge) { for (i = 0; i < ngid; i++) { sprintf(str, "f. <U\\sCoul %s\\Ne\\S-\\betaU\\N>", *(groups->grpname[groups->grps[egcENER].nm_ind[i]])); leg[e++] = strdup(str); } if (bRFExcl) { sprintf(str, "f. <U\\sRF excl\\Ne\\S-\\betaU\\N>"); leg[e++] = strdup(str); } if (EEL_FULL(fr->eeltype)) { sprintf(str, "f. <U\\sCoul recip\\Ne\\S-\\betaU\\N>"); leg[e++] = strdup(str); } } xvgr_legend(fp_tpi, 4+nener, (const char**)leg, oenv); for (i = 0; i < 4+nener; i++) { sfree(leg[i]); } sfree(leg); } clear_rvec(x_init); V_all = 0; VembU_all = 0; invbinw = 10; nbin = 10; snew(bin, nbin); /* Avoid frame step numbers <= -1 */ frame_step_prev = -1; bNotLastFrame = read_first_frame(oenv, &status, opt2fn("-rerun", nfile, fnm), &rerun_fr, TRX_NEED_X); frame = 0; if (rerun_fr.natoms - (bCavity ? nat_cavity : 0) != mdatoms->nr - (a_tp1 - a_tp0)) { gmx_fatal(FARGS, "Number of atoms in trajectory (%d)%s " "is not equal the number in the run input file (%d) " "minus the number of atoms to insert (%d)\n", rerun_fr.natoms, bCavity ? " minus one" : "", mdatoms->nr, a_tp1-a_tp0); } refvolshift = log(det(rerun_fr.box)); switch (inputrec->eI) { case eiTPI: stepblocksize = inputrec->nstlist; break; case eiTPIC: stepblocksize = 1; break; default: gmx_fatal(FARGS, "Unknown integrator %s", ei_names[inputrec->eI]); } #ifdef GMX_SIMD /* Make sure we don't detect SIMD overflow generated before this point */ gmx_simd_check_and_reset_overflow(); #endif while (bNotLastFrame) { frame_step = rerun_fr.step; if (frame_step <= frame_step_prev) { /* We don't have step number in the trajectory file, * or we have constant or decreasing step numbers. * Ensure we have increasing step numbers, since we use * the step numbers as a counter for random numbers. */ frame_step = frame_step_prev + 1; } frame_step_prev = frame_step; lambda = rerun_fr.lambda; t = rerun_fr.time; sum_embU = 0; for (e = 0; e < nener; e++) { sum_UgembU[e] = 0; } /* Copy the coordinates from the input trajectory */ for (i = 0; i < rerun_fr.natoms; i++) { copy_rvec(rerun_fr.x[i], state->x[i]); } copy_mat(rerun_fr.box, state->box); V = det(state->box); logV = log(V); bStateChanged = TRUE; bNS = TRUE; step = cr->nodeid*stepblocksize; while (step < nsteps) { /* Initialize the second counter for random numbers using * the insertion step index. This ensures that we get * the same random numbers independently of how many * MPI ranks we use. Also for the same seed, we get * the same initial random sequence for different nsteps. */ rnd_count = step*rnd_count_stride; if (!bCavity) { /* Random insertion in the whole volume */ bNS = (step % inputrec->nstlist == 0); if (bNS) { /* Generate a random position in the box */ gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd); gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2); for (d = 0; d < DIM; d++) { x_init[d] = rnd[d]*state->box[d][d]; } } if (inputrec->nstlist == 1) { copy_rvec(x_init, x_tp); } else { /* Generate coordinates within |dx|=drmax of x_init */ do { gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd); gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2); for (d = 0; d < DIM; d++) { dx[d] = (2*rnd[d] - 1)*drmax; } } while (norm2(dx) > drmax*drmax); rvec_add(x_init, dx, x_tp); } } else { /* Random insertion around a cavity location * given by the last coordinate of the trajectory. */ if (step == 0) { if (nat_cavity == 1) { /* Copy the location of the cavity */ copy_rvec(rerun_fr.x[rerun_fr.natoms-1], x_init); } else { /* Determine the center of mass of the last molecule */ clear_rvec(x_init); mass_tot = 0; for (i = 0; i < nat_cavity; i++) { for (d = 0; d < DIM; d++) { x_init[d] += mass_cavity[i]*rerun_fr.x[rerun_fr.natoms-nat_cavity+i][d]; } mass_tot += mass_cavity[i]; } for (d = 0; d < DIM; d++) { x_init[d] /= mass_tot; } } } /* Generate coordinates within |dx|=drmax of x_init */ do { gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd); gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2); for (d = 0; d < DIM; d++) { dx[d] = (2*rnd[d] - 1)*drmax; } } while (norm2(dx) > drmax*drmax); rvec_add(x_init, dx, x_tp); } if (a_tp1 - a_tp0 == 1) { /* Insert a single atom, just copy the insertion location */ copy_rvec(x_tp, state->x[a_tp0]); } else { /* Copy the coordinates from the top file */ for (i = a_tp0; i < a_tp1; i++) { copy_rvec(x_mol[i-a_tp0], state->x[i]); } /* Rotate the molecule randomly */ gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd); gmx_rng_cycle_2uniform(frame_step, rnd_count++, seed, RND_SEED_TPI, rnd+2); rotate_conf(a_tp1-a_tp0, state->x+a_tp0, NULL, 2*M_PI*rnd[0], 2*M_PI*rnd[1], 2*M_PI*rnd[2]); /* Shift to the insertion location */ for (i = a_tp0; i < a_tp1; i++) { rvec_inc(state->x[i], x_tp); } } /* Clear some matrix variables */ clear_mat(force_vir); clear_mat(shake_vir); clear_mat(vir); clear_mat(pres); /* Set the charge group center of mass of the test particle */ copy_rvec(x_init, fr->cg_cm[top->cgs.nr-1]); /* Calc energy (no forces) on new positions. * Since we only need the intermolecular energy * and the RF exclusion terms of the inserted molecule occur * within a single charge group we can pass NULL for the graph. * This also avoids shifts that would move charge groups * out of the box. * * Some checks above ensure than we can not have * twin-range interactions together with nstlist > 1, * therefore we do not need to remember the LR energies. */ /* Make do_force do a single node force calculation */ cr->nnodes = 1; do_force(fplog, cr, inputrec, step, nrnb, wcycle, top, &top_global->groups, state->box, state->x, &state->hist, f, force_vir, mdatoms, enerd, fcd, state->lambda, NULL, fr, NULL, mu_tot, t, NULL, NULL, FALSE, GMX_FORCE_NONBONDED | GMX_FORCE_ENERGY | (bNS ? GMX_FORCE_DYNAMICBOX | GMX_FORCE_NS | GMX_FORCE_DO_LR : 0) | (bStateChanged ? GMX_FORCE_STATECHANGED : 0)); cr->nnodes = nnodes; bStateChanged = FALSE; bNS = FALSE; /* Calculate long range corrections to pressure and energy */ calc_dispcorr(fplog, inputrec, fr, step, top_global->natoms, state->box, lambda, pres, vir, &prescorr, &enercorr, &dvdlcorr); /* figure out how to rearrange the next 4 lines MRS 8/4/2009 */ enerd->term[F_DISPCORR] = enercorr; enerd->term[F_EPOT] += enercorr; enerd->term[F_PRES] += prescorr; enerd->term[F_DVDL_VDW] += dvdlcorr; epot = enerd->term[F_EPOT]; bEnergyOutOfBounds = FALSE; #ifdef GMX_SIMD_X86_SSE2_OR_HIGHER /* With SSE the energy can overflow, check for this */ if (gmx_mm_check_and_reset_overflow()) { if (debug) { fprintf(debug, "Found an SSE overflow, assuming the energy is out of bounds\n"); } bEnergyOutOfBounds = TRUE; } #endif /* If the compiler doesn't optimize this check away * we catch the NAN energies. * The epot>GMX_REAL_MAX check catches inf values, * which should nicely result in embU=0 through the exp below, * but it does not hurt to check anyhow. */ /* Non-bonded Interaction usually diverge at r=0. * With tabulated interaction functions the first few entries * should be capped in a consistent fashion between * repulsion, dispersion and Coulomb to avoid accidental * negative values in the total energy. * The table generation code in tables.c does this. * With user tbales the user should take care of this. */ if (epot != epot || epot > GMX_REAL_MAX) { bEnergyOutOfBounds = TRUE; } if (bEnergyOutOfBounds) { if (debug) { fprintf(debug, "\n time %.3f, step %d: non-finite energy %f, using exp(-bU)=0\n", t, (int)step, epot); } embU = 0; } else { embU = exp(-beta*epot); sum_embU += embU; /* Determine the weighted energy contributions of each energy group */ e = 0; sum_UgembU[e++] += epot*embU; if (fr->bBHAM) { for (i = 0; i < ngid; i++) { sum_UgembU[e++] += (enerd->grpp.ener[egBHAMSR][GID(i, gid_tp, ngid)] + enerd->grpp.ener[egBHAMLR][GID(i, gid_tp, ngid)])*embU; } } else { for (i = 0; i < ngid; i++) { sum_UgembU[e++] += (enerd->grpp.ener[egLJSR][GID(i, gid_tp, ngid)] + enerd->grpp.ener[egLJLR][GID(i, gid_tp, ngid)])*embU; } } if (bDispCorr) { sum_UgembU[e++] += enerd->term[F_DISPCORR]*embU; } if (bCharge) { for (i = 0; i < ngid; i++) { sum_UgembU[e++] += (enerd->grpp.ener[egCOULSR][GID(i, gid_tp, ngid)] + enerd->grpp.ener[egCOULLR][GID(i, gid_tp, ngid)])*embU; } if (bRFExcl) { sum_UgembU[e++] += enerd->term[F_RF_EXCL]*embU; } if (EEL_FULL(fr->eeltype)) { sum_UgembU[e++] += enerd->term[F_COUL_RECIP]*embU; } } } if (embU == 0 || beta*epot > bU_bin_limit) { bin[0]++; } else { i = (int)((bU_logV_bin_limit - (beta*epot - logV + refvolshift))*invbinw + 0.5); if (i < 0) { i = 0; } if (i >= nbin) { realloc_bins(&bin, &nbin, i+10); } bin[i]++; } if (debug) { fprintf(debug, "TPI %7d %12.5e %12.5f %12.5f %12.5f\n", (int)step, epot, x_tp[XX], x_tp[YY], x_tp[ZZ]); } if (dump_pdb && epot <= dump_ener) { sprintf(str, "t%g_step%d.pdb", t, (int)step); sprintf(str2, "t: %f step %d ener: %f", t, (int)step, epot); write_sto_conf_mtop(str, str2, top_global, state->x, state->v, inputrec->ePBC, state->box); } step++; if ((step/stepblocksize) % cr->nnodes != cr->nodeid) { /* Skip all steps assigned to the other MPI ranks */ step += (cr->nnodes - 1)*stepblocksize; } } if (PAR(cr)) { /* When running in parallel sum the energies over the processes */ gmx_sumd(1, &sum_embU, cr); gmx_sumd(nener, sum_UgembU, cr); } frame++; V_all += V; VembU_all += V*sum_embU/nsteps; if (fp_tpi) { if (bVerbose || frame%10 == 0 || frame < 10) { fprintf(stderr, "mu %10.3e <mu> %10.3e\n", -log(sum_embU/nsteps)/beta, -log(VembU_all/V_all)/beta); } fprintf(fp_tpi, "%10.3f %12.5e %12.5e %12.5e %12.5e", t, VembU_all == 0 ? 20/beta : -log(VembU_all/V_all)/beta, sum_embU == 0 ? 20/beta : -log(sum_embU/nsteps)/beta, sum_embU/nsteps, V); for (e = 0; e < nener; e++) { fprintf(fp_tpi, " %12.5e", sum_UgembU[e]/nsteps); } fprintf(fp_tpi, "\n"); fflush(fp_tpi); } bNotLastFrame = read_next_frame(oenv, status, &rerun_fr); } /* End of the loop */ walltime_accounting_end(walltime_accounting); close_trj(status); if (fp_tpi != NULL) { gmx_fio_fclose(fp_tpi); } if (fplog != NULL) { fprintf(fplog, "\n"); fprintf(fplog, " <V> = %12.5e nm^3\n", V_all/frame); fprintf(fplog, " <mu> = %12.5e kJ/mol\n", -log(VembU_all/V_all)/beta); } /* Write the Boltzmann factor histogram */ if (PAR(cr)) { /* When running in parallel sum the bins over the processes */ i = nbin; global_max(cr, &i); realloc_bins(&bin, &nbin, i); gmx_sumd(nbin, bin, cr); } if (MASTER(cr)) { fp_tpi = xvgropen(opt2fn("-tpid", nfile, fnm), "TPI energy distribution", "\\betaU - log(V/<V>)", "count", oenv); sprintf(str, "number \\betaU > %g: %9.3e", bU_bin_limit, bin[0]); xvgr_subtitle(fp_tpi, str, oenv); xvgr_legend(fp_tpi, 2, (const char **)tpid_leg, oenv); for (i = nbin-1; i > 0; i--) { bUlogV = -i/invbinw + bU_logV_bin_limit - refvolshift + log(V_all/frame); fprintf(fp_tpi, "%6.2f %10d %12.5e\n", bUlogV, (int)(bin[i]+0.5), bin[i]*exp(-bUlogV)*V_all/VembU_all); } gmx_fio_fclose(fp_tpi); } sfree(bin); sfree(sum_UgembU); walltime_accounting_set_nsteps_done(walltime_accounting, frame*inputrec->nsteps); return 0; }
/* * Routine: * Purpose: * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ int pr_s_customer (void *pSrc) { struct S_CUSTOMER_TBL *r; char szTemp[6]; if (pSrc == NULL) r = &g_s_customer; else r = pSrc; print_start (S_CUSTOMER); print_id (S_CUST_ID, r->kID, 1); print_varchar (S_CUST_SALUTATION, r->pSalutation, 1); print_varchar (S_CUST_LAST_NAME, r->pLastName, 1); print_varchar (S_CUST_FIRST_NAME, r->pFirstName, 1); print_boolean (S_CUST_PREFERRED_FLAG, r->bPreferredFlag, 1); print_date (S_CUST_BIRTH_DATE, r->dtBirthDate.julian, 1); print_varchar (S_CUST_BIRTH_COUNTRY, r->pBirthCountry, 1); print_varchar (S_CUST_LOGIN, r->szLogin, 1); print_varchar (S_CUST_EMAIL, r->szEmail, 1); print_date (S_CUST_LAST_LOGIN, r->dtLastLogin.julian, 1); print_date (S_CUST_FIRST_SHIPTO_DATE, r->dtFirstShipToDate.julian, 1); print_date (S_CUST_FIRST_PURCHASE_DATE, r->dtFirstPurchaseDate.julian, 1); print_date (S_CUST_LAST_REVIEW, r->dtReview.julian, 1); print_varchar (S_CUST_PRIMARY_MACHINE, r->szPrimaryMachine, 1); print_varchar (S_CUST_SECONDARY_MACHINE, r->szSecondaryMachine, 1); print_integer (S_CUST_ADDRESS_STREET_NUM, g_w_customer_address.ca_address.street_num, 1); print_varchar (S_CUST_ADDRESS_SUITE_NUM, g_w_customer_address.ca_address.suite_num, 1); print_varchar (S_CUST_ADDRESS_STREET_NAME1, g_w_customer_address.ca_address.street_name1, 1); print_varchar (S_CUST_ADDRESS_STREET_NAME2, g_w_customer_address.ca_address.street_name2, 1); print_varchar (S_CUST_ADDRESS_STREET_TYPE, g_w_customer_address.ca_address.street_type, 1); print_varchar (S_CUST_ADDRESS_CITY, g_w_customer_address.ca_address.city, 1); sprintf (szTemp, "%05d", g_w_customer_address.ca_address.zip); print_varchar (S_CUST_ADDRESS_ZIP, szTemp, 1); print_varchar (S_CUST_ADDRESS_COUNTY, g_w_customer_address.ca_address.county, 1); print_varchar (S_CUST_ADDRESS_STATE, g_w_customer_address.ca_address.state, 1); print_varchar (S_CUST_ADDRESS_COUNTRY, g_w_customer_address.ca_address.country, 1); print_varchar (S_CUST_LOCATION_TYPE, r->pLocationType, 1); print_varchar (S_CUST_GENDER, r->sGender, 1); print_varchar (S_CUST_MARITAL_STATUS, r->pMaritalStatus, 1); print_varchar (S_CUST_EDUCATION, r->pEducation, 1); print_varchar (S_CUST_CREDIT_RATING, r->pCreditRating, 1); print_integer (S_CUST_PURCHASE_ESTIMATE, r->nPurchaseEstimate, 1); print_varchar (S_CUST_BUY_POTENTIAL, r->pBuyPotential, 1); print_integer (S_CUST_DEPENDENT_CNT, r->nDependents, 1); print_integer (S_CUST_EMPLOYED_CNT, r->nEmployed, 1); print_integer (S_CUST_COLLEGE_CNT, r->nCollege, 1); print_integer (S_CUST_VEHICLE_CNT, r->nVehicle, 1); print_decimal (S_CUST_INCOME, &r->dIncome, 0); print_end (S_CUSTOMER); return (0); }
END_TEST /* char *iter_map_2 = */ /* "cluster=1\n" */ /* "part=0 : 1 132.65.174.100 1\n" */ /* "part=0 : 2 132.65.34.139 2\n" */ /* "cluster=2\n" */ /* "part=0 : 1 132.65.34.135 4"; */ /* START_TEST (test_map_iter_2) */ /* { */ /* mapper_t map; */ /* int res; */ /* mapper_iter_t iter; */ /* mapper_node_info_t ni; */ /* int n, cn, pn, a; */ /* print_start("test_map_iter_2"); */ /* map = mapper_init(300); */ /* fail_unless(map != NULL, "Cant create a map object"); */ /* // The local node will be placed in partition 2 of cluster 1 */ /* // mapper_set_my_pe(map, PE_SET(6, 15)); */ /* res = mapper_set_from_mem(map, iter_map_2, strlen(iter_map_2)); */ /* fail_unless(res, "set_from_mem returend 0 for a valid map"); */ /* n = mapperTotalNodeNum(map); */ /* fail_unless(n == 7, "Failed to get total nodes"); */ /* cn = mapperClusterNodeNum(map); */ /* fail_unless(cn == 3, "Failed to get total cluster nodes"); */ /* pn = mapper_get_partition_node_num(map); */ /* fail_unless(pn == 3, "Failed to get total partition nodes"); */ /* // All iteratror */ /* iter = mapper_iter_init(map, MAP_ITER_ALL); */ /* fail_unless(res, "Failed to create iterator"); */ /* a = 0; */ /* while(mapper_next(iter, &ni)) */ /* a++; */ /* fail_unless(a == n, "Number of iterations is not the number of nodes"); */ /* mapper_iter_done(iter); */ /* // Cluster iteratror */ /* iter = mapper_iter_init(map, MAP_ITER_CLUSTER); */ /* fail_unless(res, "Failed to create iterator"); */ /* a = 0; */ /* while(mapper_next(iter, &ni)) */ /* a++; */ /* fail_unless(a == cn, "Number of iterations is not the number of cluster nodes"); */ /* mapper_iter_done(iter); */ /* // Partition iteratror */ /* iter = mapper_iter_init(map, MAP_ITER_PARTITION); */ /* fail_unless(res, "Failed to create iterator"); */ /* a = 0; */ /* while(mapper_next(iter, &ni)) */ /* a++; */ /* fail_unless(a == pn, "Number of iterations is not the number of partition nodes"); */ /* mapper_iter_done(iter); */ /* mapper_done(map); */ /* print_end(); */ /* } */ /* END_TEST */ START_TEST (test_mem_leak) { mapper_t map; int res; mapper_iter_t iter; mapper_node_info_t ni; int a; print_start("test_mem_leak"); //msx_set_debug(MAP_DEBUG); unsigned long beforeMemSize = getMyMemSize(); fail_unless(beforeMemSize > 0 , "Failed to get memory size"); for(int i=0 ; i<1000 ; i++) { map = BuildMosixMap(good_mosixmap_map_3, strlen(good_mosixmap_map_3) + 1, INPUT_MEM); fail_unless(map != NULL, "Failed to build map object from good_mosixmap_map_3"); iter = mapperIter(map, MAP_ITER_ALL); fail_unless(res, "Failed to create iterator"); a = 0; while(mapperNext(iter, &ni)) a++; mapperIterDone(iter); mapperDone(map); } unsigned long afterMemSize = getMyMemSize(); fail_unless(afterMemSize > 0 , "Failed to get memory size"); if(debug) fprintf(stderr, "before %lu after %lu\n", beforeMemSize, afterMemSize); fail_unless( beforeMemSize == afterMemSize); msx_set_debug(0); print_end(); }
void print_human(const struct params *prm, const struct usbmon_packet_1 *ep, const unsigned char *data, uint64_t start_sec) { struct print_cursor pcur; char udir, utype; int data_len, i; int ndesc; /* Display this many */ const struct usbmon_isodesc *dp; int cnt; ssize_t rc; print_start(&pcur, prm->print_buf, prm->print_size); if ((data_len = ep->len_cap) < 0) { /* Overflow */ data_len = 0; } #if 0 enum { TAG_BUF_SIZE = 17 }; char tag_buf[TAG_BUF_SIZE]; print_human_tag(tag_buf, TAG_BUF_SIZE, prm->tagp, ep); #endif /* * We cast into a truncated type for readability. * The danger of collisions is negligible. */ print_safe(&pcur, "%08x", (unsigned int) ep->id); udir = ((ep->epnum & 0x80) != 0) ? 'i' : 'o'; switch (ep->xfer_type & 0x3) { case PIPE_ISOCHRONOUS: utype = 'Z'; break; case PIPE_INTERRUPT: utype = 'I'; break; case PIPE_CONTROL: utype = 'C'; break; default: /* PIPE_BULK */ utype = 'B'; } print_safe(&pcur, " %u.%06u %c %c%c:%u:%03u:%u", (unsigned int)(ep->ts_sec - start_sec), ep->ts_usec, ep->type, utype, udir, ep->busnum, ep->devnum, ep->epnum & 0x7f); if (ep->type == 'E') { print_safe(&pcur, " %d", ep->status); } else { if (ep->flag_setup == 0) { /* Setup packet is present and captured */ print_safe(&pcur, " s %02x %02x %04x %04x %04x", ep->s.setup[0], ep->s.setup[1], (ep->s.setup[3] << 8) | ep->s.setup[2], (ep->s.setup[5] << 8) | ep->s.setup[4], (ep->s.setup[7] << 8) | ep->s.setup[6]); } else if (ep->flag_setup != '-') { /* Unable to capture setup packet */ print_safe(&pcur, " %c __ __ ____ ____ ____", ep->flag_setup); } else { /* No setup for this kind of URB */ if (ep->type == 'S' && ep->status == -EINPROGRESS) { print_safe(&pcur, " -"); } else { print_safe(&pcur, " %d", ep->status); } if (usb_typeisoc(ep->xfer_type) || usb_typeint(ep->xfer_type)) { print_safe(&pcur, ":%d", ep->interval); } if (usb_typeisoc(ep->xfer_type)) { print_safe(&pcur, ":%d", ep->start_frame); if (ep->type == 'C') { print_safe(&pcur, ":%d", ep->s.iso.error_count); } } } if (usb_typeisoc(ep->xfer_type)) { /* * This is the number of descriptors used by HC. */ print_safe(&pcur, " %d", ep->s.iso.numdesc); /* * This is the number of descriptors which we print. */ ndesc = ep->ndesc; if (ndesc > ISODESC_MAX) ndesc = ISODESC_MAX; if (ndesc * sizeof(struct usbmon_isodesc) > data_len) { ndesc = data_len / sizeof(struct usbmon_isodesc); } /* This is aligned by malloc */ dp = (struct usbmon_isodesc *) data; for (i = 0; i < ndesc; i++) { print_safe(&pcur, " %d:%u:%u", dp->iso_stat, dp->iso_off, dp->iso_len); dp++; } /* * The number of descriptors captured is used to * find where the data starts. */ ndesc = ep->ndesc; if (ndesc * sizeof(struct usbmon_isodesc) > data_len) { data_len = 0; } else { data += ndesc * sizeof(struct usbmon_isodesc); data_len -= ndesc * sizeof(struct usbmon_isodesc); } } } print_safe(&pcur, " %d", ep->length); if (ep->length > 0) { if (ep->flag_data == 0) { print_safe(&pcur, " =\n"); if (data_len >= prm->data_max) data_len = prm->data_max; print_human_data(&pcur, ep, data, data_len); } else { print_safe(&pcur, " %c\n", ep->flag_data); } } else { print_safe(&pcur, "\n"); } cnt = print_done(&pcur); if ((rc = write(1, prm->print_buf, cnt)) < cnt) { if (rc < 0) { fprintf(stderr, TAG ": Write error: %s\n", strerror(errno)); } else { fprintf(stderr, TAG ": Short write\n"); } exit(1); } }
void print_48(const struct params *prm, const struct usbmon_packet *ep, const unsigned char *data) { struct print_cursor pcur; char udir, utype; int data_len, i; int cnt; ssize_t rc; print_start(&pcur, prm->print_buf, prm->print_size); udir = ((ep->epnum & 0x80) != 0) ? 'i' : 'o'; switch (ep->xfer_type & 0x3) { case PIPE_ISOCHRONOUS: utype = 'Z'; break; case PIPE_INTERRUPT: utype = 'I'; break; case PIPE_CONTROL: utype = 'C'; break; default: /* PIPE_BULK */ utype = 'B'; } print_safe(&pcur, "%llx %u %c %c%c:%03u:%02u", (long long) ep->id, (unsigned int)(ep->ts_sec & 0xFFF) * 1000000 + ep->ts_usec, ep->type, utype, udir, ep->devnum, ep->epnum & 0x7f); if (ep->flag_setup == 0) { /* Setup packet is present and captured */ print_safe(&pcur, " s %02x %02x %04x %04x %04x", ep->setup[0], ep->setup[1], (ep->setup[3] << 8) | ep->setup[2], (ep->setup[5] << 8) | ep->setup[4], (ep->setup[7] << 8) | ep->setup[6]); } else if (ep->flag_setup != '-') { /* Unable to capture setup packet */ print_safe(&pcur, " %c __ __ ____ ____ ____", ep->flag_setup); } else { /* No setup for this kind of URB */ print_safe(&pcur, " %d", ep->status); } print_safe(&pcur, " %d", ep->length); if (ep->length > 0) { if (ep->flag_data == 0) { print_safe(&pcur, " ="); if ((data_len = ep->len_cap) >= DATA_MAX) data_len = DATA_MAX; for (i = 0; i < data_len; i++) { if (i % 4 == 0) { print_safe(&pcur, " "); } print_safe(&pcur, "%02x", data[i]); } print_safe(&pcur, "\n"); } else { print_safe(&pcur, " %c\n", ep->flag_data); } } else { print_safe(&pcur, "\n"); } cnt = print_done(&pcur); if ((rc = write(1, prm->print_buf, cnt)) < cnt) { if (rc < 0) { fprintf(stderr, TAG ": Write error: %s\n", strerror(errno)); } else { fprintf(stderr, TAG ": Short write\n"); } exit(1); } }
int main (int argc, char **argv) { print_start(); print_debug = 0; load_from_file = 0; char *dvalue = NULL; char *evalue = NULL; char *fvalue = NULL; char *uvalue = NULL; char *wvalue = NULL; int hflag = 0; int Fflag = 0; int Xflag = 0; int Eflag = 0; int Aflag = 0; int index; int c; opterr = 0; // compute the options while ((c = getopt (argc, argv, "d:e:f:u:w:lphFXEA")) != -1) switch (c) { case 'd': dvalue = optarg; break; case 'e': evalue = optarg; break; case 'l': load_from_file = 1; break; case 'f': fvalue = optarg; break; case 'u': uvalue = optarg; break; case 'w': wvalue = optarg; break; case 'h': hflag = 1; break; case 'F': Fflag = 1; break; case 'X': Xflag = 1; break; case 'E': Eflag = 1; break; case 'A': Aflag = 1; break; case 'p': print_debug = 1; break; case '?': if (optopt == 'd') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (optopt == 'e') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (optopt == 'f') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (optopt == 'u') fprintf (stderr, "Option -%c requires an argument.\n", optopt); else if (optopt == 'w') fprintf (stderr, "Option -%w requires an argument.\n", optopt); else if (isprint (optopt)) fprintf (stderr, "Unknown option `-%c'.\n", optopt); else fprintf (stderr, "Unknown option character `\\x%x'.\n", optopt); return 1; default: abort (); } // print help if (hflag) print_help(); else if (load_from_file) { //write LVALUE to defs.h FILE *file_def; file_def = fopen ("defs.h","w"); if (file_def == NULL) { printf ("Error open defs.h\n"); return -1; } //fseek (file_def, 0, SEEK_END); fprintf (file_def, "#define LVALUE\n"); fclose(file_def); } // write shellcode from a given file to defs.h else if (fvalue) { printf ("write shellcode from %s to defs.h\n", fvalue); FILE *file_def; file_def = fopen ("defs.h","w"); if (file_def == NULL) { printf ("Error open defs.h\n"); return -1; } fseek (file_def, 0, SEEK_END); // read the shellcode file, write to defs.h FILE *file_sh = fopen ( fvalue, "r" ); if ( file_sh != NULL ) { if(Eflag) fprintf (file_def, "#define FVALUE \""); else fprintf (file_def, "#define FVALUE \"\"\n"); char line [ 5000 ]; while ( fgets ( line, sizeof line, file_sh ) != NULL ) fprintf (file_def, "%s", line); if(Eflag) fprintf (file_def, "\"\n"); //fprintf (file_def, "\\n"); fclose ( file_sh ); } else printf ("Error open %s\n", fvalue); fclose (file_def); } // exec from url else if (uvalue) { printf ("write url %s to defs.h\n", uvalue); FILE *file_def; file_def = fopen ("defs.h","w"); if (file_def == NULL) { printf ("Error open defs.h\n"); return -1; } fseek (file_def, 0, SEEK_END); fprintf (file_def, "#define UVALUE \"%s\"\n", uvalue); fclose (file_def); } //write flags to defs.h FILE *file_def; file_def = fopen ("defs.h","a"); if (file_def == NULL) { printf ("Error open defs.h\n"); return -1; } //write LVALUE to defs.h if(print_debug) fprintf (file_def, "#define PRINT_DEBUG\n"); //write SANDBOX_FOPEN to defs.h if(Fflag) fprintf (file_def, "#define SANDBOX_FOPEN\n"); //write X64 to defs.h if(Xflag) fprintf (file_def, "#define X64\n"); //write ENCRYPT to defs.h if(Eflag) fprintf (file_def, "#define ENCRYPT\n"); //write ASCIIMSF to defs.h if(Aflag) fprintf (file_def, "#define ASCIIMSF\n"); fclose(file_def); } //main
int main(int argc, char *argv[]) { int freelist = 0, ret = 0; alpm_errno_t err; const char *target_name; alpm_pkg_t *pkg; alpm_list_t *dblist = NULL; if(parse_options(argc, argv) != 0) { usage(); ret = 1; goto finish; } handle = alpm_initialize(ROOTDIR, dbpath, &err); if(!handle) { fprintf(stderr, "error: cannot initialize alpm: %s\n", alpm_strerror(err)); ret = 1; goto finish; } if(searchsyncs) { if(register_syncs() != 0) { ret = 1; goto finish; } dblist = alpm_get_syncdbs(handle); } else { dblist = alpm_list_add(dblist, alpm_get_localdb(handle)); freelist = 1; } /* we only care about the first non option arg for walking */ target_name = argv[optind]; pkg = alpm_find_dbs_satisfier(handle, dblist, target_name); if(!pkg) { fprintf(stderr, "error: package '%s' not found\n", target_name); ret = 1; goto finish; } print_start(alpm_pkg_get_name(pkg), target_name); tdepth d = { NULL, NULL, 1 }; walk_deps(dblist, pkg, &d, reverse); print_end(); if(freelist) { alpm_list_free(dblist); } finish: cleanup(); return ret; }