void RamFileSystemSerialise::serialise_folder(RamFileSystem::Folder *folder) { write_binary(folder->id()); _output << 'f'; auto num_writable = 0u; for (auto iter = folder->begin(); iter != folder->end(); ++iter) { auto type = iter->second->metadata().type(); if (type == MOUNT_POINT_ENTRY || type == CHARACTER_DEVICE_ENTRY) { continue; } num_writable++; } write_binary(num_writable); for (auto iter = folder->begin(); iter != folder->end(); ++iter) { auto type = iter->second->metadata().type(); if (type == MOUNT_POINT_ENTRY || type == CHARACTER_DEVICE_ENTRY) { continue; } write_string(iter->first); write_binary(iter->second->id()); } }
static size_t red_record_data_chunks_ptr(FILE *fd, const char *prefix, RedMemSlotInfo *slots, int group_id, int memslot_id, QXLDataChunk *qxl) { size_t data_size = qxl->data_size; int count_chunks = 0; QXLDataChunk *cur = qxl; int error; while (cur->next_chunk) { cur = (QXLDataChunk*)get_virt(slots, cur->next_chunk, sizeof(*cur), group_id, &error); data_size += cur->data_size; count_chunks++; } fprintf(fd, "data_chunks %d %ld\n", count_chunks, data_size); validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id); write_binary(fd, prefix, qxl->data_size, qxl->data); while (qxl->next_chunk) { memslot_id = get_memslot_id(slots, qxl->next_chunk); qxl = (QXLDataChunk*)get_virt(slots, qxl->next_chunk, sizeof(*qxl), group_id, &error); validate_virt(slots, (intptr_t)qxl->data, memslot_id, qxl->data_size, group_id); write_binary(fd, prefix, qxl->data_size, qxl->data); } return data_size; }
inline int binary_compare(const T &a, const T &b){ std::vector<uint8_t> a_bytes(binary_length(a)); std::vector<uint8_t> b_bytes(binary_length(b)); write_binary(a_bytes.data(), a); write_binary(b_bytes.data(), b); if(a_bytes == b_bytes){ return 0; } return (a_bytes < b_bytes) ? -1 : 1; }
void binary_reader::stock_data::write_raw( std::ofstream& out ) { write_binary( out, stock_name_ ); write_binary( out, date_time_ ); write_binary( out, price_ ); write_binary( out, vwap_ ); write_binary( out, volume_ ); write_binary( out, f1_ ); write_binary( out, t1_ ); write_binary( out, f2_ ); write_binary( out, f3_ ); write_binary( out, f4_ ); }
static void red_record_surface_cmd(FILE *fd, RedMemSlotInfo *slots, int group_id, QXLPHYSICAL addr) { QXLSurfaceCmd *qxl; size_t size; int error; qxl = (QXLSurfaceCmd *)get_virt(slots, addr, sizeof(*qxl), group_id, &error); fprintf(fd, "surface_cmd\n"); fprintf(fd, "surface_id %d\n", qxl->surface_id); fprintf(fd, "type %d\n", qxl->type); fprintf(fd, "flags %d\n", qxl->flags); switch (qxl->type) { case QXL_SURFACE_CMD_CREATE: fprintf(fd, "u.surface_create.format %d\n", qxl->u.surface_create.format); fprintf(fd, "u.surface_create.width %d\n", qxl->u.surface_create.width); fprintf(fd, "u.surface_create.height %d\n", qxl->u.surface_create.height); fprintf(fd, "u.surface_create.stride %d\n", qxl->u.surface_create.stride); size = qxl->u.surface_create.height * abs(qxl->u.surface_create.stride); if ((qxl->flags & QXL_SURF_FLAG_KEEP_DATA) != 0) { write_binary(fd, "data", size, (uint8_t*)get_virt(slots, qxl->u.surface_create.data, size, group_id, &error)); } break; } }
bool MCSessionWriteSession(MCSession *p_session) { bool t_success = true; t_success = write_binary(p_session->filehandle, p_session->data, p_session->data_length); return t_success; }
static int erl_json_ei_string(void* ctx, const unsigned char* val, unsigned int len) { State* pState = (State*) ctx; flog(stderr, "string", 0, (const char*)val, len); list_header_for_value(pState); write_binary(pState, (const char*)val, len); return 1; }
void RamFileSystemSerialise::serialise_file(RamFileSystem::File *file) { write_binary(file->id()); _output << 'd'; uint8_t *temp = new uint8_t[file->size()]; file->read(0, file->size(), temp); write_string(temp, file->size()); delete [] temp; }
static void red_record_virt_data_flat(FILE *fd, const char *prefix, RedMemSlotInfo *slots, int group_id, QXLPHYSICAL addr, size_t size) { int error; write_binary(fd, prefix, size, (uint8_t*)get_virt(slots, addr, size, group_id, &error)); }
void red_record_dev_input_primary_surface_create(FILE *fd, QXLDevSurfaceCreate* surface, uint8_t *line_0) { fprintf(fd, "%d %d %d %d\n", surface->width, surface->height, surface->stride, surface->format); fprintf(fd, "%d %d %d %d\n", surface->position, surface->mouse_mode, surface->flags, surface->type); write_binary(fd, "data", line_0 ? abs(surface->stride)*surface->height : 0, line_0); }
static void red_record_message(FILE *fd, RedMemSlotInfo *slots, int group_id, QXLPHYSICAL addr) { QXLMessage *qxl; int error; /* * security alert: * qxl->data[0] size isn't specified anywhere -> can't verify * luckily this is for debug logging only, * so we can just ignore it by default. */ qxl = (QXLMessage *)get_virt(slots, addr, sizeof(*qxl), group_id, &error); write_binary(fd, "message", strlen((char*)qxl->data), (uint8_t*)qxl->data); }
void jag_store::convert_conduit_to_binary(const std::vector<std::string> &conduit_filenames) { m_num_converted_samples = 0; if (m_comm->get_procs_in_world() != 1) { throw lbann_exception(std::string{} + __FILE__ + " " + std::to_string(__LINE__) + " :: you must run convert_conduit with a single processor"); } options *opts = options::get(); std::string output_dir = opts->get_string("convert_conduit"); if (m_master) { char b[128]; sprintf(b, "mkdir --mode=770 -p %s", output_dir.c_str()); system(b); write_binary_metadata(output_dir); } write_binary(conduit_filenames, output_dir); }
int main(int argc, char **argv) { if (argc != 6) { std::cout << "\nUsage:\n" << argv[0] << " file.bin ncols width jump h\n" << "file.bin contains media properties with curvy interface\n" << "ncols is number of columns in binary file\n" << "width is size of part of interface for jump (in cells) - not used with second version\n" << "jump is heigth of jump of interface (in cells)\n" << "h is cell size (m)\n\n"; return 1; } try { const std::string filename = std::string(argv[1]); const int n_cols = atoi(argv[2]); const int width = atoi(argv[3]); const int jump = atoi(argv[4]); const float h = atof(argv[5]); float *values = NULL; int n_rows; read_binary(filename, n_cols, &n_rows, &values); float *curvy_line = new float[n_cols]; // y-coordinates of the line get_curvy_line(values, n_cols, n_rows, h, curvy_line); // make_super_curvy(values, n_cols, n_rows, width, jump); make_super_curvy2(values, n_cols, n_rows, jump, h, curvy_line); write_binary(file_stem(filename) + "_curvy.bin", values, n_cols, n_rows); delete[] values; } catch (const std::exception& e) { std::cout << "\n" << e.what() << "\n" << std::endl; return 2; } catch (...) { std::cout << "\n\n\nUnknown exception!\n\n" << std::endl; return 3; } return 0; }
static int erl_json_ei_map_key(void* ctx, const unsigned char* buf, unsigned int len) { State* pState = (State*) ctx; flog(stderr, "map key", 0, buf, len); list_header_for_value(pState); write_tuple_header(pState, 2); switch(keys_as(pState)) { case EEP0018_PARSE_KEYS_AS_ATOM: write_atom(pState, (const char*)buf, len); break; case EEP0018_PARSE_KEYS_AS_BINARY: write_binary(pState, (const char*)buf, len); break; } pState->skip_list_header_for_value = -1; return 1; }
static void red_record_stroke_ptr(FILE *fd, RedMemSlotInfo *slots, int group_id, QXLStroke *qxl, uint32_t flags) { int error; red_record_path(fd, slots, group_id, qxl->path); fprintf(fd, "attr.flags %d\n", qxl->attr.flags); if (qxl->attr.flags & SPICE_LINE_FLAGS_STYLED) { int style_nseg = qxl->attr.style_nseg; uint8_t *buf; fprintf(fd, "attr.style_nseg %d\n", qxl->attr.style_nseg); spice_assert(qxl->attr.style); buf = (uint8_t *)get_virt(slots, qxl->attr.style, style_nseg * sizeof(QXLFIXED), group_id, &error); write_binary(fd, "style", style_nseg * sizeof(QXLFIXED), buf); } red_record_brush_ptr(fd, slots, group_id, &qxl->brush, flags); fprintf(fd, "fore_mode %d\n", qxl->fore_mode); fprintf(fd, "back_mode %d\n", qxl->back_mode); }
void binary_reader::stock_data::write( std::ofstream& out ) { boost::uint32_t date = 0; int month; int day; int year; std::sscanf( date_time_, "%4d%2d%2d", &year, &month, &day ); date = ( year - 1 ) * 372 + ( month - 1 )* 31 + day; static char stock_name[ 9 ]; memcpy( stock_name, stock_name_, sizeof( stock_name_ ) ); write_binary( out, stock_name ); write_binary( out, date ); write_binary( out, vwap_ ); write_binary( out, volume_ ); write_binary( out, f1_ ); write_binary( out, f4_ ); write_binary( out, f3_ ); //std::cout << " name:" << stock_name << " date:" << date << " volume:" << volume_ << " f3_:" << f3_ << std::endl; }
int main(int argc, char *argv[]) { int i, j, k, l, index, indexaux, Np, idPart; int ii, jj, kk; double xc, yc, zc; // Positions of the cells double xp, yp, zp, vxp, vyp, vzp; // Positions and velocities of the particles double Window_fn; //Window function double norm_factor; //Normalization factor for the momentum computation char *inFile=NULL; FILE *outfile=NULL, *outfile1=NULL, *outfile2=NULL; /*----- For verifications -----*/ double totalMass=0.0; double totMassCIC=0.0; int sumaPart = 0; if(argc < 2) { printf("Error: Incomplete number of parameters. Execute as follows:\n"); printf("%s Parameters_file\n", argv[0]); exit(0); }//if inFile = argv[1]; /************************************************* READING DATA FILE *************************************************/ /*+++++ Reading parameters +++++*/ printf("Reading parameters file\n"); printf("--------------------------------------------------\n\n"); read_parameters( inFile ); printf("Parameters file read!\n"); printf("--------------------------------------------------\n\n"); printf("Reading data file\n"); printf("--------------------------------------------------\n\n"); #ifdef BINARYDATA /*+++++ Reading binary data file +++++*/ read_binary(); GV.NGRID3 = GV.NGRID * GV.NGRID * GV.NGRID; GV.dx = GV.L / (1.0*GV.NGRID); GV.volCell = GV.dx*GV.dx*GV.dx; #endif #ifdef ASCIIDATA /*+++++ Allocating memory +++++*/ part = (struct particle *) calloc((size_t) GV.NpTot,sizeof(struct particle)); /*+++++ Reading data file +++++*/ read_ascii( GV.FILENAME ); /*+++++ Simulation parameters +++++*/ GV.NGRID3 = GV.NGRID * GV.NGRID * GV.NGRID; GV.dx = GV.L / ((double) GV.NGRID); GV.volCell = GV.dx*GV.dx*GV.dx; #endif printf("Data file read!\n"); printf("--------------------------------------------------\n\n"); /*+++++ Computing mean density +++++*/ printf("Computing mean density\n"); printf("--------------------------------------------------\n\n"); for(i=0; i<GV.NpTot; i++) { totalMass += part[i].mass; }//for i GV.rhoMean = totalMass / pow(GV.L, 3.0); // Mean density in 1e10M_sun/Mpc^3 printf("-----------------------------------------------\n"); printf("Cosmological parameters:\n"); printf("OmegaM0=%lf OmegaL0=%lf redshift=%lf HubbleParam=%lf\n", GV.OmegaM0, GV.OmegaL0, GV.zRS, GV.HubbleParam); printf("-----------------------------------------------\n"); printf("Simulation parameters:\n"); printf("NGRID=%d NGRID3=%d Particle_Mass=%lf NpTotal=%ld \nrhoMean=%lf L=%lf volCell=%lf dx=%lf \nFilename=%s\n", GV.NGRID, GV.NGRID3, GV.mass, GV.NpTot, GV.rhoMean, GV.L, GV.volCell, GV.dx, GV.FILENAME); printf("-----------------------------------------------\n"); /************************************************* FROM PARTICLES TO GRID *************************************************/ /*+++++ Array of structure Cell, size NGRID^3 +++++*/ printf("Allocating memory\n"); printf("-----------------------------------------------\n"); cells = (struct Cell *) calloc( GV.NGRID3, sizeof( struct Cell) ); printf("Memory allocated\n"); printf("-----------------------------------------------\n"); /*----- Setting values to zero at the beggining -----*/ for(i=0; i<GV.NGRID3; i++){ cells[i].Np_cell = 0; cells[i].denCon = 0.0; cells[i].rho = 0.0; }//for i printf("Locating cells\n"); printf("-----------------------------------------------\n"); /*++++ Locating cells +++++*/ for(i=0; i<GV.NpTot; i++) { locateCell(part[i].pos[X], part[i].pos[Y], part[i].pos[Z], i, cells); }//for i printf("Particles located in the grid\n"); printf("-----------------------------------------------\n"); printf("Performing the mass assignment\n"); printf("-----------------------------------------------\n"); /*+++++ Distribution scheme +++++*/ for(i=0; i<GV.NGRID; i++) { for(j=0; j<GV.NGRID; j++) { for(k=0; k<GV.NGRID; k++) { /*----- Index of the cell -----*/ index = INDEX(i,j,k); // C-order /*----- Coordinates in the center of the cell -----*/ xc = GV.dx*(0.5 + i); yc = GV.dx*(0.5 + j); zc = GV.dx*(0.5 + k); /*----- Number of particles in the cell -----*/ Np = cells[index].Np_cell; for(l=0; l<Np; l++) { /*::::: Particle ID :::::*/ idPart = cells[index].id_part[l]; /*::::: Coordinates of the particle :::::*/ xp = part[idPart].pos[X]; yp = part[idPart].pos[Y]; zp = part[idPart].pos[Z]; /*::::: Mass and momentum assignment to neighbour cells (CIC) :::::*/ for(ii=-1; ii<=1; ii++) { for(jj=-1; jj<=1; jj++) { for(kk=-1; kk<=1; kk++) { indexaux = INDEX(mod(i+ii,GV.NGRID),mod(j+jj,GV.NGRID),mod(k+kk,GV.NGRID)); xc = GV.dx*(0.5 + i+ii); yc = GV.dx*(0.5 + j+jj); zc = GV.dx*(0.5 + k+kk); /*----- Mass with CIC assignment scheme ------*/ Window_fn = W(xc-xp, yc-yp, zc-zp, GV.dx); cells[indexaux].rho += part[idPart].mass * Window_fn; }//for kk }//for jj }//for ii }//for l }//for k }//for j }//for i free(part); /*+++++ Saving output file in ASCII format +++++*/ #ifdef ASCIIDATA outfile = fopen(strcat(GV.FILENAME,"_DenCon_CIC.dat"),"w"); fprintf(outfile, "%s%9s %12s %12s %12s %12s %12s\n", "#", "Index", "NumberOfPars", "x", "y", "z", "DenCon"); for(i=0; i<GV.NGRID; i++) { for(j=0; j<GV.NGRID; j++) { for(k=0; k<GV.NGRID; k++) { index = INDEX(i,j,k); // C-order /*----- coordinates of the centre of the cell -----*/ xc = GV.dx * (0.5 + i); yc = GV.dx * (0.5 + j); zc = GV.dx * (0.5 + k); /*----- Calculating the final density in the cell -----*/ totMassCIC += cells[index].rho; /* We have not divided by the volume yet. This is still the mass */ cells[index].rho = cells[index].rho / GV.volCell; //This is the actual density /*----- Verification of number of particles -----*/ sumaPart += cells[index].Np_cell; /*----- Calculating the final density contrast in the cell -----*/ cells[index].denCon = (cells[index].rho/GV.rhoMean) - 1.0; fprintf(outfile, "%10d %10d %12.6lf %12.6lf %12.6lf %12.6lf\n", index, cells[index].Np_cell, xc, yc, zc, cells[index].denCon); }//for k }// for j }// for i fclose(outfile); #endif /*+++++ Writing binary file +++++*/ #ifdef BINARYDATA for(i=0; i<GV.NGRID; i++) { for(j=0; j<GV.NGRID; j++) { for(k=0; k<GV.NGRID; k++) { index = INDEX(i,j,k); // C-order /*----- coordinates of the centre of the cell -----*/ cells[index].pos[X] = GV.dx * (0.5 + i); cells[index].pos[Y] = GV.dx * (0.5 + j); cells[index].pos[Z] = GV.dx * (0.5 + k); /*----- Calculating the final density in the cell -----*/ totMassCIC += cells[index].rho; /* We have not divided by the volume yet. This is still the mass */ cells[index].rho = cells[index].rho / GV.volCell; //This is the actual density /*----- Verification of number of particles -----*/ sumaPart += cells[index].Np_cell; /*----- Calculating the final density contrast in the cell -----*/ cells[index].denCon = (cells[index].rho/GV.rhoMean) - 1.0; }//for k }// for j }// for i write_binary(); #endif printf("Total number of particles:%10d\n", sumaPart); printf("Mass CIC = %lf\n",totMassCIC); printf("Mass Simulation = %lf\n", totalMass); /*+++++ Freeing up memory allocation +++++*/ free(cells); printf("Code has finished successfully\n"); return 0; }//main
inline uint64_t compute_hash(const T &x, m3bp::size_type modulo){ const auto len = binary_length(x); std::vector<uint8_t> buf(len); write_binary(buf.data(), x); return m3bp::hash_byte_sequence(buf.data(), len, modulo); }
void RamFileSystemSerialise::write_string(const uint8_t *str, uint32_t size) { write_binary(size); _output.write(reinterpret_cast<const char *>(str), size); }
void RamFileSystemSerialise::write_string(const char *str, uint32_t size) { write_binary(size); _output.write(str, size); }
static void time_integration_loop_hubble(Forceinfo *fi, Nbodyinfo *nb) { double zval; /* red shift at T=0 */ double tmpzz; double t, t0, dt1, tpresent; double W, K, E0, E, Q; double cm[3], cmv[3]; int step = 0; double tsnapout, timageout; t = 0.0; tpresent = 16.0; /* present time must be 16.0 */ zval = 24.0; tmpzz = pow(1.0/(zval+1), 3.0/2.0); t0 = tmpzz/(1.0-tmpzz)*tpresent; fi->eps = (zval+1)*pow(t0/(tpresent+t0), 2.0/3.0)*eps0; dt1 = dt0; tsnapout = dtsnapout; timageout = dtimageout; PR(t0, f); PR(dt0, f); PRL(dt1, f); PR(tstart,f); PR(tpresent,f); PR(dt,f); PRL(dtsnapout,f); PRL(dtimageout,f); if (cputime_flag) { vtc_turnon_cputime(); } vtc_init_cputime(); vtc_print_cputime("initial vtc_get_force start at"); #if DIRECT /* direct sum */ if (grape_flag) { vtc_set_scale(512.0, nb->m[0]); fi->calculator = GRAPE_FORCEONLY; vtc_get_force_direct(fi, nb); #if CALCPOTENTIAL fi->calculator = GRAPE_POTENTIALONLY; vtc_get_force_direct(fi, nb); fi->calculator = GRAPE_FORCEONLY; #endif } else { vtc_get_force_direct(fi, nb); } #else /* tree */ if (grape_flag) { fi->calculator = GRAPE_FORCEONLY; vtc_get_force_tree(fi, nb); #if CALCPOTENTIAL fi->calculator = GRAPE_POTENTIALONLY; vtc_get_force_tree(fi, nb); fi->calculator = GRAPE_FORCEONLY; #endif } else { vtc_get_force_tree(fi, nb); } #endif /* direct/tree */ vtc_print_cputime("initial vtc_get_force end at"); fprintf(stderr, "ninteraction: %e list_len_avg: %6.5f nwalk: %d\n", fi->ninteraction, (double)fi->ninteraction/nb->n, fi->nwalk); K = get_kinetic_energy(nb); #if CALCPOTENTIAL W = get_potential_energy(nb); E = E0 = W+K; PR(E0, f); PR(W, f); #endif PRL(K, f); plot_nbody(t, nb); /* calculate force at T=0 and quit */ if (snapout_flag && dtsnapout == 0.0) { static int nout = 0; char fn[255]; snapout_acc_flag = 1; sprintf(fn, snapoutfile, nout); PRL(fn, s); if (ionemo_flag) { write_binary(fn, t, nb); } else if (usepob_flag) { write_pob(fn, t, nb); } else { write_ascii(fn, t, nb); } vtc_print_cputime("exit at"); return; } while (t < tend) { if (fi->eps < eps) { double eps1; eps1 = (zval+1)*pow((t+t0)/(tpresent+t0), 2.0/3.0)*eps0; fi->eps = (eps1 < eps ? eps1 : eps); } else { fi->eps = eps; } if (dt1 < dt) { dt1 = dt0*(t+t0)/t0; } else { dt1 = dt; } if (step%outlogstep == outlogstep - 1 && cputime_flag) { vtc_turnon_cputime(); } else { vtc_turnoff_cputime(); } push_velocity(0.5*dt1, nb); push_position(dt1, nb); vtc_init_cputime(); #if DIRECT /* direct sum */ vtc_get_force_direct(fi, nb); #else /* tree */ vtc_get_force_tree(fi, nb); #endif /* direct/tree */ vtc_print_cputime("vtc_get_force end at"); push_velocity(0.5*dt1, nb); vtc_print_cputime("integration end at"); plot_nbody(t, nb); if (step%outlogstep == outlogstep - 1) { fprintf(stderr, "ninteraction: %e list_len_avg: %6.5f nwalk: %d\n", fi->ninteraction, fi->ninteraction/nb->n, fi->nwalk); K = get_kinetic_energy(nb); #if CALCPOTENTIAL if (grape_flag) { fi->calculator = GRAPE_POTENTIALONLY; #if DIRECT /* direct sum */ vtc_get_force_direct(fi, nb); #else /* tree */ vtc_get_force_tree(fi, nb); #endif /* direct/tree */ fi->calculator = GRAPE_FORCEONLY; } W = get_potential_energy(nb); E = W+K; Q = K/(K-E); fprintf(stderr, "\nT= %f K= %f Q= %f E= %f Eerr= %f Eabserr= %f\n", t, K, Q, E, (E0-E)/E0, E0-E); #else fprintf(stderr, "\nT= %f K= %f\n", t, K); #endif fprintf(stderr, "step: %d\n", step); fprintf(stderr, "T: %f current eps: %f dt: %f\n", t, fi->eps, dt1); get_cmterms(nb, cm, cmv); fprintf(stderr, "CM %15.13e %15.13e %15.13e\n", cm[0], cm[1], cm[2]); fprintf(stderr, "CMV %15.13e %15.13e %15.13e\n", cmv[0], cmv[1], cmv[2]); } if (tsnapout < t && snapout_flag) { static int nout = 0; char fn[255]; char cmd[255]; sprintf(fn, snapoutfile, nout); PRL(fn, s); if (ionemo_flag) { write_binary(fn, t, nb); } else if (usepob_flag) { write_pob(fn, t, nb); } else { write_ascii(fn, t, nb); } if (command_exec_flag) { sprintf(cmd, "%s %s %03d", command_name, fn, nout); fprintf(stderr, "execute %s\n", cmd); system(cmd); } nout++; PR(t, f); PRL(fn, s); tsnapout += dtsnapout; } if (timageout < t && imageout_flag) { static int nout = 0; char fn[255]; char cmd[255]; sprintf(fn, snapoutfile, nout); strcat(fn, ".gif"); PRL(fn, s); vtc_plotstar(nb->x, nb->n, t, image_scale, fn); nout++; PR(t, f); PRL(fn, s); timageout += dtimageout; } t += dt1; step++; vtc_print_cputime("exit at"); } /* main loop */ }
int main() { int i, j, k, l, index, indexaux, Np, idPart; int ii, jj, kk; int icor, jcor, kcor; int suma = 0; double xc, yc, zc, vxc, vyc, vzc; // Positions and velocities of the cells double xp, yp, zp, vxp, vyp, vzp; // Positions and velocities of the particles FILE *outfile; double foo = 0.0; double mass; /*GSL*/ const gsl_rng_type * T; /*Define el tipo de generador de números aleatorios. No hay que liberarlo*/ gsl_rng * r; /*Análogo al w. Puntero que contiene la info sobre cual generador se va a usar,cantidad de memoria a usar, etc.*/ long seed; /*Plummer*/ double aux_x, aux_y, aux_z, aux_rad; double ux, uy, uz; int count_n = 0; double Plummer_max, TMass, aSL; FILE *outFile=NULL; ////////////////////////////////// //* READING GADGET BINARY FILE *// ////////////////////////////////// printf("Reading parameters file\n"); read_parameters("./Parameters_files/parameters_file.dat"); GV.NpTot = 300000.0; //GV.NpTot = 1000.0; printf("Parameters file read. Let's work with N=%lf particles\n", GV.NpTot); /* Simulation parameters */ GV.L = 400.0; GV.NGRID3 = GV.NGRID * GV.NGRID * GV.NGRID; GV.mass = 1.0; GV.rhoMean = (GV.mass * GV.NpTot) / pow(GV.L,3); // Mean density in 1e10M_sun/Mpc^3 GV.dx = GV.L / (1.0* GV.NGRID); GV.volCell = GV.dx*GV.dx*GV.dx; part = (struct particle *) calloc((size_t) GV.NpTot,sizeof(struct particle)); printf("Memory Allocated\n"); /*+++++ Initializing random generation of numbers +++++*/ gsl_rng_env_setup();//Inicializa las rutinas de generación T = gsl_rng_default;/*Inicialización de T con esta variable de GSL que es la default*/ r = gsl_rng_alloc(T);/*Alocación de memoria*/ seed = time(NULL)*getpid(); gsl_rng_set(r, seed);/*Recibe puntero de inicialización de generación y un entero largo como semilla*/ /*+++++ Rejection method +++++*/ printf("Performing Rejection\n"); /*----- Maximum value of the Plummer function -----*/ TMass = 100.0; aSL = 10.0; Plummer_max = aSL * aSL * aSL; Plummer_max = 4 * M_PI * Plummer_max; Plummer_max = (3.0 * TMass) / Plummer_max; outFile = fopen("./../../Processed_data/Plummer_parts.bin", "w"); while(count_n < GV.NpTot + 1) { aux_x = GV.L * gsl_rng_uniform (r); aux_y = GV.L * gsl_rng_uniform (r); aux_z = GV.L * gsl_rng_uniform (r); //aux_rad = aux_x*aux_x + aux_y*aux_y + aux_z*aux_z; //aux_rad = sqrt(aux_rad); ux = Plummer_max * gsl_rng_uniform (r); uy = Plummer_max * gsl_rng_uniform (r); uz = Plummer_max * gsl_rng_uniform (r); if( ux < Plummer( aux_x, aSL, TMass) ) //if( ux < Plummer( aux_rad, aSL, TMass) ) { if( uy < Plummer( aux_y, aSL, TMass) ) //if( uy < Plummer( aux_rad, aSL, TMass) ) { if( uz < Plummer( aux_z, aSL, TMass) ) //if( uz < Plummer( aux_rad, aSL, TMass) ) { /* part[i].posx = Plummer_inv(ux, aSL, TMass); part[i].posy = Plummer_inv(uy, aSL, TMass); part[i].posz = Plummer_inv(uz, aSL, TMass); */ part[i].posx = aux_x; part[i].posy = aux_y; part[i].posz = aux_z; part[i].id = count_n; part[i].mass = 1.0; part[i].velx = 0.0; part[i].vely = 0.0; part[i].velz = 0.0; if((count_n%500000)==0) { printf("particle %d finished\n", count_n); } fprintf(outFile, "%16.8lf %16.8lf %16.8lf\n", part[i].posx, part[i].posy, part[i].posz); count_n++; }//if z }//if y }//if x }//while fclose(outFile); printf("Rejection finished!\n"); printf("Total number of parts GV.NpTot = %lf, count_n=%d\n", count_n, GV.NpTot); gsl_rng_free (r); /* Cosmological parameters */ //GV.OmegaM0 = Header.Omega0; //GV.OmegaL0 = Header.OmegaLambda; //GV.zRS = Header.redshift; //GV.HubbleParam = Header.HubbleParam; /* printf("-----------------------------------------------\n"); printf("Cosmological parameters:\n"); printf("OmegaM0=%lf OmegaL0=%lf redshift=%lf HubbleParam=%lf\n", GV.OmegaM0, GV.OmegaL0, GV.zRS, GV.HubbleParam); printf("-----------------------------------------------\n"); */ printf("Simulation parameters:\n"); printf("NGRID=%d NGRID3=%d Particle_Mass=%lf NpTotal=%lf rhoMean=%lf L=%lf volCell=%lf dx=%lf Filename=%s\n", GV.NGRID, GV.NGRID3, GV.mass, GV.NpTot, GV.rhoMean, GV.L, GV.volCell, GV.dx, GV.FILENAME); printf("-----------------------------------------------\n"); ////////////////////////////// //* FROM PARTICLES TO GRID *// ////////////////////////////// /* Array of structure Cell, size NGRID^3 */ cells = (struct Cell *)calloc( GV.NGRID3, sizeof( struct Cell) ); // Setting values to zero at the beggining for(i=0; i<GV.NGRID3; i++){ cells[i].Np_cell = 0; cells[i].denCon = 0.0; cells[i].rho = 0.0; cells[i].velx = 0.0; cells[i].vely = 0.0; cells[i].velz = 0.0; } /* Locating cells */ for(i=0; i<GV.NpTot; i++){ locateCell(part[i].posx, part[i].posy, part[i].posz, i, cells); } printf("Particles located in the grid\n"); printf("-----------------------------------------------\n"); /* Distribution scheme */ for(i=0; i<GV.NGRID; i++){ for(j=0; j<GV.NGRID; j++){ for(k=0; k<GV.NGRID; k++){ /* Index of the cell */ index = INDEX(i,j,k); // C-order /* coordinates in the center of the cell */ xc = GV.dx*(0.5 + i); yc = GV.dx*(0.5 + j); zc = GV.dx*(0.5 + k); /* Number of particles in the cell */ Np = cells[index].Np_cell; if(Np == 0){ cells[index].velx = 0.0; cells[index].vely = 0.0; cells[index].velz = 0.0; continue; } for(l=0; l<Np; l++){ /* Particle ID */ idPart = cells[index].id_part[l]; /* Coordinates of the particle */ xp = part[idPart].posx; yp = part[idPart].posy; zp = part[idPart].posz; /* Velocities of the particle */ vxp = part[idPart].velx; vyp = part[idPart].vely; vzp = part[idPart].velz; /* Cell velocity assignment: At the end of the for at l-index we are going to toke the ratio with respect to Np, in order to get the mean of the volocities in each cell. */ cells[index].velx += vxp; cells[index].vely += vyp; cells[index].velz += vzp; for(ii=-1; ii<=1; ii++){ for(jj=-1; jj<=1; jj++){ for(kk=-1; kk<=1; kk++){ indexaux = INDEX(mod(i+ii,GV.NGRID),mod(j+jj,GV.NGRID),mod(k+kk,GV.NGRID)); xc = GV.dx*(0.5 + i+ii); yc = GV.dx*(0.5 + j+jj); zc = GV.dx*(0.5 + k+kk); cells[indexaux].rho += GV.mass * W(xc-xp, yc-yp, zc-zp, GV.dx); } } } }//for l /* Cell velocity assignment: At the end of the for at l-index we are going to toke the ratio with respect to Np, in order to get the mean of the volocities in each cell. */ cells[index].velx = cells[index].velx / ((double) Np); cells[index].vely = cells[index].vely / ((double) Np); cells[index].velz = cells[index].velz / ((double) Np); }//for k }//for j }//for i /* outfile = fopen("dens_uniform.dat","w"); fprintf(outfile, "%s%9s %12s %12s %12s %12s %12s %12s %12s %12s %12s\n", "#", "Index", "x", "y", "z", "vx", "vy", "vz", "rho", "DenCon", "Np_cell"); */ for(i=0; i<GV.NGRID; i++){ for(j=0; j<GV.NGRID; j++){ for(k=0; k<GV.NGRID; k++){ index = INDEX(i,j,k); // C-order /* coordinates of the cell (in the center of) */ xc = GV.dx * (0.5 + i); yc = GV.dx * (0.5 + j); zc = GV.dx * (0.5 + k); cells[index].pos[X] = xc; cells[index].pos[Y] = yc; cells[index].pos[Z] = zc; /* Calculating the final density in the cell */ cells[index].rho = cells[index].rho / GV.volCell; /* Calculating the final density contrast in the cell */ cells[index].denCon = (cells[index].rho/GV.rhoMean) - 1.0; /* Writting in the file */ /*fprintf(outfile, "%10d %12.6lf %12.6lf %12.6lf %12.6lf %12.6lf %12.6lf %12.6lf %12.6lf %10d\n", index, xc, yc, zc, cells[index].velx, cells[index].vely, cells[index].velz, cells[index].rho, cells[index].denCon, cells[index].Np_cell); */ }//for k }// for j }// for i //fclose(outfile); /* Writting in the file */ write_binary(); /* Freeing up memory allocation */ free(part); free(cells); return 0; }
int main(int argc, char *argv[]) { //============= set up MPI ================= MPI_Status status; const int root_process = 0; int ierr, my_id, an_id, num_procs; // tag for MPI message: energy minimization convergence const int tag_99 = 99; // initialize MPI, get my_id for this process and total number of processes ierr = MPI_Init(&argc, &argv); ierr = MPI_Comm_rank(MPI_COMM_WORLD, &my_id); ierr = MPI_Comm_size(MPI_COMM_WORLD, &num_procs); //============ get input files ============= // default filenames char input_gro[MAX_STR_LEN], input_param[MAX_STR_LEN], input_mdset[MAX_STR_LEN]; strcpy(input_gro, "init.gro"); strcpy(input_param, "param.txt"); strcpy(input_mdset, "mdset.txt"); // parse arguments (input files) // -gro for gro file // -par for parameter file // -mds for MD settings int iarg = 1; while (1) { if (iarg >= argc) { break; } if (0 == strcmp(argv[iarg], "-gro") && iarg < argc) { strcpy(input_gro, argv[iarg + 1]); iarg += 2; } else if (0 == strcmp(argv[iarg], "-par") && iarg < argc) { strcpy(input_param, argv[iarg + 1]); iarg += 2; } else if (0 == strcmp(argv[iarg], "-mds") && iarg < argc) { strcpy(input_mdset, argv[iarg + 1]); iarg += 2; } else { ++ iarg; } } //========= define variables and read MD settings =========== // varialbles to read from input_mdset RunSet *p_runset = my_malloc(sizeof(RunSet)); Metal *p_metal = my_malloc(sizeof(Metal)); // read md settings from input_mdset read_settings(input_mdset, p_runset, p_metal); // initialize timer time_t start_t = time(NULL); struct timeval tv; gettimeofday(&tv, NULL); double start_time = (tv.tv_sec) + (tv.tv_usec) * 1.0e-6; // time_used[0] = total // time_used[1] = QSC density // time_used[2] = QSC force // time_used[3] = Bonded // time_used[4] = Nonbonded // time_used[5] = CPIM matrix // time_used[6] = CPIM vector // time_used[7] = CPIM solve // time_used[8] = CPIM force // time_used[10] = QSC density communication double **time_used = my_malloc(sizeof(double *) * num_procs); for(an_id = 0; an_id < num_procs; ++ an_id) { time_used[an_id] = my_malloc(sizeof(double) * 15); int it; for(it = 0; it < 15; ++ it) { time_used[an_id][it] = 0.0; } } // Coulomb type: cut_off, wolf_sum if (0 == strcmp(p_runset->coulomb_type, "cut_off" )) { p_runset->use_coulomb = 0; } else if (0 == strcmp(p_runset->coulomb_type, "wolf_sum")) { p_runset->use_coulomb = 1; } else { printf("Error: unknown coulomb_type %s!\n", p_runset->coulomb_type); exit(1); } // Damped shifted force (DSF) approach for electrostatics // Ref.: Fennell and Gezelter, J. Chem. Phys. 2006, 124, 234104 // dx.doi.org/10.1063/1.2206581 // Based on: Wolf et al., J. Chem. Phys. 1999, 110, 8254 // dx.doi.org/10.1063/1.478738 // Zahn et al., J. Phys. Chem. B 2002, 106, 10725-10732 // dx.doi.org/10.1021/jp025949h // Benchmark: McCann and Acevedo, J. Chem. Theory Comput. 2013, 9, 944-950 // dx.doi.org/10.1021/ct300961e // note: p_runset->rCut and p_runset->w_alpha were read from mdset.txt p_runset->rCut2 = p_runset->rCut * p_runset->rCut; double rCut = p_runset->rCut; double rCut2 = p_runset->rCut2; double w_alpha = p_runset->w_alpha; p_runset->w_a2_sqrtPI = w_alpha * 2.0 * INV_SQRT_PI; p_runset->w_Const = erfc(w_alpha * rCut) / rCut2 + p_runset->w_a2_sqrtPI * exp(-w_alpha * w_alpha * rCut2) / rCut; p_runset->w_erfc_arCut = erfc(w_alpha * rCut)/ rCut; // van der Waals type: cut_off or shifted if (0 == strcmp(p_runset->vdw_type, "cut_off")) { p_runset->use_vdw = 0; } else if (0 == strcmp(p_runset->vdw_type, "shifted")) { p_runset->use_vdw = 1; } else { printf("Error: unknown vdw_type %s!\n", p_runset->vdw_type); exit(1); } // Shifted force method for Lennard-Jones potential // Ref: Toxvaerd and Dyre, J. Chem. Phys. 2011, 134, 081102 // dx.doi.org/10.1063/1.3558787 p_runset->inv_rc12 = 1.0 / pow(rCut, 12.0); p_runset->inv_rc6 = 1.0 / pow(rCut, 6.0); //============== read force field parameters from param.txt ================= Topol *p_topol = my_malloc(sizeof(Topol)); int mol, atom; int number_VSites, number_Cstrs; // variables for bonded and nonbonded interaction // CPIM: capacitance-polarizability interaction model // Ref.: a) Jensen and Jensen, J. Phys. Chem. C, 2008, 112, 15697-15703 // dx.doi.org/10.1021/jp804116z // b) Morton and Jensen, J. Chem. Phys., 2010, 133, 074103 // dx.doi.org/10.1063/1.3457365 // // p_metal->cpff_polar: polarizability // p_metal->cpff_capac: capacitance // p_metal->n_NPs: number of nanoparticles // p_metal->cpff_chg: total charge of a nanoparticle // p_metal->start_NP: first atom of a nanoparticle // p_metal->end_NP: last atom of a nanoparticle // read parameters from input_param, step 1 read_param_1(input_param, p_topol, p_metal); // allocate memory for arrays // CPIM charge and indices p_metal->cpff_chg = my_malloc(p_metal->n_NPs * sizeof(double)); p_metal->start_NP = my_malloc(p_metal->n_NPs * sizeof(int)); p_metal->end_NP = my_malloc(p_metal->n_NPs * sizeof(int)); // molecules and atom parameters // For a given molecule type (mol from 0 to p_topol->mol_types-1): // p_topol->atom_num[mol]: its number of atoms // p_topol->mol_num[mol]: the number of this type of molecule in the system p_topol->atom_num = my_malloc(p_topol->mol_types * sizeof(int)); p_topol->mol_num = my_malloc(p_topol->mol_types * sizeof(int)); p_topol->atom_param = my_malloc(p_topol->mol_types * sizeof(AtomParam *)); // van der Waals interaction parameters NonbondedParam *data_nonbonded = my_malloc_2(p_topol->n_types * p_topol->n_types * sizeof(NonbondedParam), "data_nonbonded"); p_topol->nonbonded_param = my_malloc(p_topol->n_types * sizeof(NonbondedParam *)); int i_type; for(i_type = 0; i_type < p_topol->n_types; ++ i_type) { p_topol->nonbonded_param[i_type] = &(data_nonbonded[p_topol->n_types * i_type]); } // bonded potentials: bond, pair, angle, dihedral int *data_bonded = my_malloc(sizeof(int) * p_topol->mol_types * 6); p_topol->n_bonds = &(data_bonded[0]); p_topol->n_pairs = &(data_bonded[p_topol->mol_types]); p_topol->n_angles = &(data_bonded[p_topol->mol_types * 2]); p_topol->n_dihedrals = &(data_bonded[p_topol->mol_types * 3]); p_topol->n_vsites = &(data_bonded[p_topol->mol_types * 4]); p_topol->n_constraints = &(data_bonded[p_topol->mol_types * 5]); p_topol->vsite_funct = my_malloc(p_topol->mol_types * sizeof(int *)) ; p_topol->bond_param = my_malloc(p_topol->mol_types * sizeof(BondParam *)); p_topol->pair_param = my_malloc(p_topol->mol_types * sizeof(PairParam *)) ; p_topol->angle_param = my_malloc(p_topol->mol_types * sizeof(AngleParam *)); p_topol->dihedral_param = my_malloc(p_topol->mol_types * sizeof(DihedralParam *)) ; p_topol->vsite_4 = my_malloc(p_topol->mol_types * sizeof(VSite_4 *)) ; p_topol->constraint = my_malloc(p_topol->mol_types * sizeof(Constraint *)) ; p_topol->exclude = my_malloc(p_topol->mol_types * sizeof(int **)) ; // Quantum Sutton-Chen densities for metal if (p_metal->min >=0 && p_metal->max >= p_metal->min) { p_metal->inv_sqrt_dens = my_malloc(sizeof(double) * p_metal->num); } // read parameters from input_param, step 2 read_param_2(input_param, p_topol, p_metal); int nAtoms = p_topol->n_atoms; int nMols = p_topol->n_mols; // count number of virtual sites and constraints number_VSites = 0; number_Cstrs = 0; for(mol = 0; mol < p_topol->mol_types; ++ mol) { number_VSites += p_topol->n_vsites[mol] * p_topol->mol_num[mol]; number_Cstrs += p_topol->n_constraints[mol] * p_topol->mol_num[mol]; } // Gaussian distribution width for capacitance-polarizability model // see Mayer, Phys. Rev. B 2007, 75, 045407 // and Jensen, J. Phys. Chem. C 2008, 112, 15697 p_metal->inv_polar = 1.0 / p_metal->cpff_polar; p_metal->inv_capac = 1.0 / p_metal->cpff_capac; double R_q = sqrt(2.0 / M_PI) * p_metal->cpff_capac; double R_p = pow(sqrt(2.0 / M_PI) * p_metal->cpff_polar / 3.0, 1.0 / 3.0); p_metal->inv_R_qq = 1.0 / sqrt(R_q * R_q + R_q * R_q); p_metal->inv_R_pq = 1.0 / sqrt(R_p * R_p + R_q * R_q); p_metal->inv_R_pp = 1.0 / sqrt(R_p * R_p + R_p * R_p); // print info if (root_process == my_id) { printf("\n"); printf(" +-----------------------------------------------------+\n"); printf(" | CapacMD program version 1.0 |\n"); printf(" | Xin Li, TheoChemBio, KTH, Stockholm |\n"); printf(" +-----------------------------------------------------+\n"); printf("\n"); printf(" .------------------ reference paper ------------------.\n"); printf("\n"); printf(" Molecular Dynamics Simulations using a Capacitance-Polarizability Force Field,\n"); printf(" Xin Li and Hans Agren, J. Phys. Chem. C, 2015, DOI: 10.1021/acs.jpcc.5b04347\n"); printf("\n"); printf("\n"); printf(" Calculation started at %s", ctime(&start_t)); printf(" Parallelized via MPI, number of processors = %d\n", num_procs); printf("\n"); printf("\n"); printf(" .------------------ run parameters -------------------.\n"); printf("\n"); printf(" run_type = %s, ensemble = %s\n", p_runset->run_type, p_runset->ensemble); printf(" vdw_type = %s, coulomb_type = %s\n", p_runset->vdw_type, p_runset->coulomb_type); printf(" rCut = %.3f nm, ", rCut); if (1 == p_runset->use_coulomb) { printf("alpha = %.3f nm^-1", p_runset->w_alpha); } printf("\n"); printf(" ref_T = %.1f K\n", p_runset->ref_temp); printf("\n"); printf("\n"); printf(" .------------------- molecule info -------------------.\n"); printf("\n"); printf(" There are %d types of molecules.\n", p_topol->mol_types); printf("\n"); for(mol = 0; mol < p_topol->mol_types; ++ mol) { printf(" Molecule[%5d], num= %5d\n", mol, p_topol->mol_num[mol]); for(atom = 0; atom < p_topol->atom_num[mol]; ++ atom) { printf(" Atom[%5d], charge= %8.3f, mass= %8.3f, atomtype= %5d\n", atom, p_topol->atom_param[mol][atom].charge, p_topol->atom_param[mol][atom].mass, p_topol->atom_param[mol][atom].atomtype); } printf("\n"); } printf("\n"); } //=========== distribute molecules/atoms/metals among the procs ============== Task *p_task = my_malloc(sizeof(Task)); int *data_start_end = my_malloc(sizeof(int) * num_procs * 6); p_task->start_mol = &(data_start_end[0]); p_task->end_mol = &(data_start_end[num_procs]); p_task->start_atom = &(data_start_end[num_procs * 2]); p_task->end_atom = &(data_start_end[num_procs * 3]); p_task->start_metal = &(data_start_end[num_procs * 4]); p_task->end_metal = &(data_start_end[num_procs * 5]); find_start_end(p_task->start_mol, p_task->end_mol, nMols, num_procs); find_start_end(p_task->start_atom, p_task->end_atom, nAtoms, num_procs); find_start_end(p_task->start_metal, p_task->end_metal, p_metal->num, num_procs); long int *data_long_start_end = my_malloc(sizeof(long int) * num_procs * 2); p_task->start_pair = &(data_long_start_end[0]); p_task->end_pair = &(data_long_start_end[num_procs]); long int n_pairs = nAtoms * (nAtoms - 1) / 2; find_start_end_long(p_task->start_pair, p_task->end_pair, n_pairs, num_procs); //============= assign indices, masses and charges ======================= // For each atom in the system (i from 0 to p_topol->n_atoms-1) // atom_info[i].iAtom: the index of this atom in its molecule type // atom_info[i].iMol: the index of its molecule type // atom_info[i].molID: the index of its molecule in the system // For each molecule in the system (im from 0 to p_topol->n_mols-1) // mol_info[im].mini: the index of its first atom in the system // mol_info[im].maxi: the index of its last atom in the system Atom_Info *atom_info = my_malloc(nAtoms * sizeof(Atom_Info)); Mol_Info *mol_info = my_malloc(nMols * sizeof(Mol_Info)); assign_indices(p_topol, p_metal, atom_info, mol_info); //======= allocate memory for coordinates, velocities and forces ========== System *p_system = my_malloc(sizeof(System)); // potential energy // p_system->potential[0] = total energy // p_system->potential[1] = metal quantum Sutton-Chen energy // p_system->potential[2] = non-metal bond stretching energy // p_system->potential[3] = non-metal angle bending energy // p_system->potential[4] = non-metal torsional energy // p_system->potential[5] = // p_system->potential[6] = Long range Coulomb // p_system->potential[7] = Coulomb energy (including 1-4) // p_system->potential[8] = vdW energy (including 1-4) // p_system->potential[9] = // p_system->potential[10] = CPIM metal charge - non-metal charge // p_system->potential[11] = CPIM metal dipole - non-metal charge // p_system->potential[12] = CPIM metal charge - metal charge // p_system->potential[13] = CPIM metal charge - metal dipole // p_system->potential[14] = CPIM metal dipole - metal dipole double *data_potential = my_malloc(sizeof(double) * 15 * 2); p_system->potential = &(data_potential[0]); p_system->partial_pot = &(data_potential[15]); p_system->old_potential = 0.0; // virial tensor p_system->virial = my_malloc(DIM * sizeof(double*)); p_system->partial_vir = my_malloc(DIM * sizeof(double*)); double *data_vir = my_malloc(DIM*2 * DIM * sizeof(double)); int i; for (i = 0; i < DIM; ++ i) { p_system->virial[i] = &(data_vir[DIM * i]); p_system->partial_vir[i] = &(data_vir[DIM * (DIM + i)]); } // box size // Note: for now we treat rectangular box only. // "p_system->box" has six elements // the first three are length in x, y, z // the second three are half of the length in x, y, z p_system->box = my_malloc(sizeof(double) * DIM*2); // coordinates, velocities and forces double *data_rvf = my_malloc_2(nAtoms*7 * DIM * sizeof(double), "data_rvf"); p_system->rx = &(data_rvf[0]); p_system->ry = &(data_rvf[nAtoms]); p_system->rz = &(data_rvf[nAtoms*2]); p_system->vx = &(data_rvf[nAtoms*3]); p_system->vy = &(data_rvf[nAtoms*4]); p_system->vz = &(data_rvf[nAtoms*5]); p_system->fx = &(data_rvf[nAtoms*6]); p_system->fy = &(data_rvf[nAtoms*7]); p_system->fz = &(data_rvf[nAtoms*8]); // forces from slave processors p_system->partial_fx = &(data_rvf[nAtoms*9]); p_system->partial_fy = &(data_rvf[nAtoms*10]); p_system->partial_fz = &(data_rvf[nAtoms*11]); // old position for RATTLE constraints p_system->old_rx = &(data_rvf[nAtoms*12]); p_system->old_ry = &(data_rvf[nAtoms*13]); p_system->old_rz = &(data_rvf[nAtoms*14]); // old force for CG optimization p_system->old_fx = &(data_rvf[nAtoms*15]); p_system->old_fy = &(data_rvf[nAtoms*16]); p_system->old_fz = &(data_rvf[nAtoms*17]); // direction for CG optimization p_system->sx = &(data_rvf[nAtoms*18]); p_system->sy = &(data_rvf[nAtoms*19]); p_system->sz = &(data_rvf[nAtoms*20]); //================ read input gro file ================== // vQ and vP are "velocities" of the thermostat/barostat particles p_system->vQ = 0.0; p_system->vP = 0.0; int groNAtoms; read_gro(input_gro, p_system, &groNAtoms, atom_info); if (groNAtoms != nAtoms) { printf("Error: groNAtoms(%d) not equal to nAtoms(%d)!\n", groNAtoms, nAtoms); exit(1); } // half of box length for PBC p_system->box[3] = p_system->box[0] * 0.5; p_system->box[4] = p_system->box[1] * 0.5; p_system->box[5] = p_system->box[2] * 0.5; p_system->volume = p_system->box[0] * p_system->box[1] * p_system->box[2]; p_system->inv_volume = 1.0 / p_system->volume; //================== set MD variables ========================== // degree of freedom p_system->ndf = 3 * (nAtoms - number_VSites) - 3 - number_Cstrs; // temperature coupling; kT = kB*T, in kJ mol^-1 p_runset->kT = K_BOLTZ * p_runset->ref_temp; p_system->qMass = (double)p_system->ndf * p_runset->kT * p_runset->tau_temp * p_runset->tau_temp; //p_system->pMass = (double)p_system->ndf * p_runset->kT * p_runset->tau_pres * p_runset->tau_pres; // temperature control p_system->first_temp = 0.0; p_system->ext_temp = 0.0; // time step p_runset->dt_2 = 0.5 * p_runset->dt; //=================== CPIM matrix and arrays ========================= // Relay matrix // external electric field and potential // induced dipoles and charges double *data_relay = NULL; // dimension of matrix: 4M + n_NPs int n_mat = p_metal->num * 4 + p_metal->n_NPs; // initialize mat_relay, vec_ext and vec_pq if (p_metal->min >=0 && p_metal->max >= p_metal->min) { data_relay = my_malloc_2(sizeof(double) * n_mat * 3, "data_relay"); p_metal->vec_pq = &(data_relay[0]); p_metal->vec_ext = &(data_relay[n_mat]); p_metal->diag_relay = &(data_relay[n_mat * 2]); int i_mat; for(i_mat = 0; i_mat < n_mat; ++ i_mat) { p_metal->vec_pq[i_mat] = 0.0; p_metal->vec_ext[i_mat] = 0.0; p_metal->diag_relay[i_mat] = 1.0; } } //================== compute forces ========================== mpi_force(p_task, p_topol, atom_info, mol_info, p_runset, p_metal, p_system, my_id, num_procs, time_used); //========== file handles: gro, vec_pq, binary dat, parameters ======== FILE *file_gro, *file_pq, *file_dat; file_gro = NULL; file_pq = NULL; file_dat = NULL; //========== adjust velocities and write trajectories ================= if (root_process == my_id) { // sum potential energies sum_potential(p_system->potential); // update temperature remove_comm(nAtoms, atom_info, p_system); kinetic_energy(p_system, nAtoms, atom_info); // save the starting temperature p_system->first_temp = p_system->inst_temp; p_system->ext_temp = p_runset->ref_temp; // creat traj.gro for writing file_gro = fopen("traj.gro","w") ; if (NULL == file_gro) { printf( "Cannot write to traj.gro!\n" ) ; exit(1); } // creat vec_pq.txt for writing file_pq = fopen("vec_pq.txt","w") ; if (NULL == file_pq) { printf( "Cannot write to vec_pq.txt!\n" ) ; exit(1); } // creat traj.dat for writing file_dat = fopen("traj.dat","w") ; if (NULL == file_dat) { printf( "Cannot write to traj.dat!\n" ) ; exit(1); } // get maximal force get_fmax_rms(nAtoms, p_system); // write the starting geometry to gro and dat file write_gro(file_gro, p_system, nAtoms, atom_info, 0); write_binary(file_dat, p_system, nAtoms, 0); if (p_metal->min >=0 && p_metal->max >= p_metal->min) { write_vec_pq(file_pq, p_metal, 0); } printf(" .---------------- start MD calculation ---------------.\n"); printf("\n"); // check p_runset->run_type if (0 == strcmp(p_runset->run_type, "em") || 0 == strcmp(p_runset->run_type, "cg")) { printf(" Step %-5d Fmax=%10.3e E=%15.8e\n", 0, p_system->f_max, p_system->potential[0]); } else if (0 == strcmp(p_runset->run_type, "md")) { printf(" %10.3f Fmax=%.2e E=%.6e T=%.3e\n", 0.0, p_system->f_max, p_system->potential[0], p_system->inst_temp); } } //========= Now start MD steps ============================ int step = 0; //=================================================== // Energy minimization using steepest descent or CG //=================================================== if (0 == strcmp(p_runset->run_type, "em") || 0 == strcmp(p_runset->run_type, "cg")) { p_system->vQ = 0.0; p_system->vP = 0.0; int converged = 0; double gamma = 0.0; double delta_pot; // initialize direction sx,sy,sz for(i = 0; i < nAtoms; ++ i) { p_system->old_fx[i] = p_system->fx[i]; p_system->old_fy[i] = p_system->fy[i]; p_system->old_fz[i] = p_system->fz[i]; p_system->sx[i] = p_system->fx[i]; p_system->sy[i] = p_system->fy[i]; p_system->sz[i] = p_system->fz[i]; } for(step = 1; step <= p_runset->em_steps && 0 == converged; ++ step) { // update coordinates on root processor if (root_process == my_id) { p_system->old_potential = p_system->potential[0]; for(i = 0; i < nAtoms; ++ i) { p_system->old_rx[i] = p_system->rx[i]; p_system->old_ry[i] = p_system->ry[i]; p_system->old_rz[i] = p_system->rz[i]; // fix metal coordinates? if (1 == p_metal->fix_pos && 1 == atom_info[i].is_metal) { continue; } p_system->rx[i] += p_system->sx[i] / p_system->f_max * p_runset->em_length; p_system->ry[i] += p_system->sy[i] / p_system->f_max * p_runset->em_length; p_system->rz[i] += p_system->sz[i] / p_system->f_max * p_runset->em_length; } // apply constraints rattle_1st(p_runset->dt, mol_info, atom_info, p_topol, p_system); // zero velocities for(i = 0; i < nAtoms; ++ i) { p_system->vx[i] = 0.0; p_system->vy[i] = 0.0; p_system->vz[i] = 0.0; } } // update forces mpi_force(p_task, p_topol, atom_info, mol_info, p_runset, p_metal, p_system, my_id, num_procs, time_used); if (root_process == my_id) { // check potential and fmax on root processor sum_potential(p_system->potential); get_fmax_rms(nAtoms, p_system); delta_pot = p_system->potential[0] - p_system->old_potential; if (delta_pot <= 0.0) { p_runset->em_length *= 1.2; } else { p_runset->em_length *= 0.2; } // print info and write to the gro file printf(" Step %-5d Fmax=%10.3e E=%15.8e\n", step, p_system->f_max, p_system->potential[0]); // write trajectories write_gro(file_gro, p_system, nAtoms, atom_info, step); write_binary(file_dat, p_system, nAtoms, step); if (p_metal->min >=0 && p_metal->max >= p_metal->min) { write_vec_pq(file_pq, p_metal, step); } // check convergence if (p_system->f_max < p_runset->em_tol && p_system->f_rms < p_runset->em_tol * 0.5 && fabs(delta_pot) < p_runset->em_tol * 0.1) { printf("\n"); printf(" F_max (%13.6e) smaller than %e\n", p_system->f_max, p_runset->em_tol); printf(" F_rms (%13.6e) smaller than %e\n", p_system->f_rms, p_runset->em_tol * 0.5); printf(" delta_E (%13.6e) smaller than %e\n", delta_pot, p_runset->em_tol * 0.1); printf("\n"); printf(" =========== Optimization converged ============\n"); converged = 1; } else { // update gamma for CG optimization // for steep descent, gamma = 0.0 if (0 == strcmp(p_runset->run_type, "cg")) { double g22 = 0.0; double g12 = 0.0; double g11 = 0.0; for(i = 0; i < nAtoms; ++ i) { g22 += p_system->fx[i] * p_system->fx[i] + p_system->fy[i] * p_system->fy[i] + p_system->fz[i] * p_system->fz[i]; g12 += p_system->old_fx[i] * p_system->fx[i] + p_system->old_fy[i] * p_system->fy[i] + p_system->old_fz[i] * p_system->fz[i]; g11 += p_system->old_fx[i] * p_system->old_fx[i] + p_system->old_fy[i] * p_system->old_fy[i] + p_system->old_fz[i] * p_system->old_fz[i]; } gamma = (g22 - g12) / g11; } for(i = 0; i < nAtoms; ++ i) { p_system->sx[i] = p_system->fx[i] + gamma * p_system->sx[i]; p_system->sy[i] = p_system->fy[i] + gamma * p_system->sy[i]; p_system->sz[i] = p_system->fz[i] + gamma * p_system->sz[i]; p_system->old_fx[i] = p_system->fx[i]; p_system->old_fy[i] = p_system->fy[i]; p_system->old_fz[i] = p_system->fz[i]; } } // communicate convergence for(an_id = 1; an_id < num_procs; ++ an_id) { ierr = MPI_Send(&converged, 1, MPI_INT, an_id, tag_99, MPI_COMM_WORLD); } } else { ierr = MPI_Recv(&converged, 1, MPI_INT, root_process, tag_99, MPI_COMM_WORLD, &status); } // exit loop if converged if (1 == converged) { break; } } } //=============================== // MD with nvt ensemble //=============================== else if (0 == strcmp(p_runset->run_type, "md")) { for (step = 1; step <= p_runset->nSteps; ++ step) { if (root_process == my_id) { // gradually increase the reference temperature if (step < p_runset->nHeating) { p_runset->ref_temp = p_system->first_temp + (p_system->ext_temp - p_system->first_temp) * step / p_runset->nHeating; } else { p_runset->ref_temp = p_system->ext_temp; } // update kT accordingly p_runset->kT = K_BOLTZ * p_runset->ref_temp; // thermostat for 1st half step if (0 == strcmp(p_runset->ensemble, "nvt")) { nose_hoover(p_runset, p_system, nAtoms); } // update velocity for 1st half step for(i = 0; i < nAtoms; ++ i) { // fix metal coordinates? if (1 == p_metal->fix_pos && 1 == atom_info[i].is_metal) { continue; } // for virtual sites, inv_mass == 0.0; double inv_mass = atom_info[i].inv_mass; p_system->vx[i] += p_runset->dt_2 * p_system->fx[i] * inv_mass; p_system->vy[i] += p_runset->dt_2 * p_system->fy[i] * inv_mass; p_system->vz[i] += p_runset->dt_2 * p_system->fz[i] * inv_mass; } // update position for the whole time step // using velocity at half time step for(i = 0; i < nAtoms; ++ i) { // fix metal coordinates? if (1 == p_metal->fix_pos && 1 == atom_info[i].is_metal) { continue; } p_system->old_rx[i] = p_system->rx[i]; p_system->old_ry[i] = p_system->ry[i]; p_system->old_rz[i] = p_system->rz[i]; p_system->rx[i] += p_runset->dt * p_system->vx[i]; p_system->ry[i] += p_runset->dt * p_system->vy[i]; p_system->rz[i] += p_runset->dt * p_system->vz[i]; } // apply constraints for the 1st half rattle_1st(p_runset->dt, mol_info, atom_info, p_topol, p_system); } // compute forces mpi_force(p_task, p_topol, atom_info, mol_info, p_runset, p_metal, p_system, my_id, num_procs, time_used); // update velocities if (root_process == my_id) { // sum potential energies sum_potential(p_system->potential); // update velocity for 2nd half step for(i = 0; i < nAtoms; ++ i) { // fix metal coordinates? if (1 == p_metal->fix_pos && 1 == atom_info[i].is_metal) { continue; } // for virtual sites, inv_mass == 0.0; double inv_mass = atom_info[i].inv_mass; p_system->vx[i] += p_runset->dt_2 * p_system->fx[i] * inv_mass; p_system->vy[i] += p_runset->dt_2 * p_system->fy[i] * inv_mass; p_system->vz[i] += p_runset->dt_2 * p_system->fz[i] * inv_mass; } // apply constraints for the 2nd half rattle_2nd(p_runset->dt, mol_info, atom_info, p_topol, p_system); // update temperature kinetic_energy(p_system, nAtoms, atom_info); // thermostat for 2nd half step if (0 == strcmp(p_runset->ensemble, "nvt")) { nose_hoover(p_runset, p_system, nAtoms); } // remove center of mass motion and update temperature remove_comm(nAtoms, atom_info, p_system); kinetic_energy(p_system, nAtoms, atom_info); // print information for this step if (0 == step % p_runset->nSave) { // apply PBC apply_pbc(nMols, mol_info, p_system->rx, p_system->ry, p_system->rz, p_system->box); get_fmax_rms(nAtoms, p_system); printf(" %10.3f Fmax=%.2e E=%.6e T=%.3e (%.1f)\n", p_runset->dt * step, p_system->f_max, p_system->potential[0], p_system->inst_temp, p_runset->ref_temp); // write to dat file write_binary(file_dat, p_system, nAtoms, step); } // regularly write to gro file if (0 == step % (p_runset->nSave*10)) { write_gro(file_gro, p_system, nAtoms, atom_info, step); if (p_metal->min >=0 && p_metal->max >= p_metal->min) { write_vec_pq(file_pq, p_metal, step); } } } } } //=========== Finalize MD ==================== sum_time_used(time_used, my_id, num_procs); if (root_process == my_id) { fclose(file_dat); fclose(file_pq); fclose(file_gro); #ifdef DEBUG int i; for(i = 0; i < nAtoms; ++ i) { printf(" f[%5d]= %12.5e, %12.5e, %12.5e\n", i, p_system->fx[i], p_system->fy[i], p_system->fz[i]); } #endif printf("\n"); printf("\n"); printf(" .------------- final potential energies --------------.\n"); printf("\n"); print_potential(p_system->potential); time_t end_t = time(NULL); gettimeofday(&tv, NULL); double end_time = (tv.tv_sec) + (tv.tv_usec) * 1.0e-6; printf(" Calculation ended normally at %s", ctime(&end_t)); printf(" %.3f seconds were used\n", end_time - start_time ); printf("\n"); printf("\n"); printf(" .------------------- time usage ----------------------.\n"); printf("\n"); analyze_time_used(time_used, num_procs); printf("\n"); } // free arrays for(an_id = 0; an_id < num_procs; ++ an_id) { free(time_used[an_id]); } free(time_used); free(p_metal->cpff_chg); free(p_metal->start_NP); free(p_metal->end_NP); free(data_bonded); data_bonded = NULL; for(mol = 0; mol < p_topol->mol_types; ++ mol) { int atom_i; for(atom_i = 0; atom_i < p_topol->atom_num[mol]; ++ atom_i) { free(p_topol->exclude[mol][atom_i]); } free(p_topol->exclude[mol]); free(p_topol->bond_param[mol]); free(p_topol->pair_param[mol]); free(p_topol->angle_param[mol]); free(p_topol->dihedral_param[mol]); free(p_topol->vsite_4[mol]); free(p_topol->vsite_funct[mol]); free(p_topol->constraint[mol]); } free(p_topol->exclude); free(p_topol->bond_param); free(p_topol->pair_param); free(p_topol->angle_param); free(p_topol->dihedral_param); p_topol->bond_param = NULL; p_topol->pair_param = NULL; p_topol->angle_param = NULL; p_topol->dihedral_param = NULL; free(p_topol->vsite_4); free(p_topol->vsite_funct); p_topol->vsite_4 = NULL; p_topol->vsite_funct = NULL; free(p_topol->constraint); p_topol->constraint = NULL; free(p_topol->mol_num); free(p_topol->atom_num); for(mol = 0; mol < p_topol->mol_types; ++ mol) { free(p_topol->atom_param[mol]); } free(p_topol->atom_param); if (p_metal->min >=0 && p_metal->max >= p_metal->min) { free(p_metal->inv_sqrt_dens); p_metal->inv_sqrt_dens = NULL; free(data_relay); //free(p_metal->mat_relay); data_relay = NULL; //p_metal->mat_relay = NULL; p_metal->vec_pq = NULL; p_metal->vec_ext = NULL; p_metal->diag_relay = NULL; } free(data_start_end); free(data_long_start_end); data_start_end = NULL; data_long_start_end = NULL; p_task->start_mol = NULL; p_task->end_mol = NULL; p_task->start_atom = NULL; p_task->end_atom = NULL; p_task->start_metal = NULL; p_task->end_metal = NULL; p_task->start_pair = NULL; p_task->end_pair = NULL; free(atom_info); free(mol_info); atom_info = NULL; mol_info = NULL; free(data_potential); data_potential = NULL; p_system->potential = NULL; p_system->partial_pot = NULL; free(p_system->virial); free(p_system->partial_vir); free(data_vir); free(p_system->box); p_system->box = NULL; free(data_rvf); data_rvf = NULL; p_system->rx = NULL; p_system->ry = NULL; p_system->rz = NULL; p_system->vx = NULL; p_system->vy = NULL; p_system->vz = NULL; p_system->fx = NULL; p_system->fy = NULL; p_system->fz = NULL; p_system->partial_fx = NULL; p_system->partial_fy = NULL; p_system->partial_fz = NULL; p_system->old_rx = NULL; p_system->old_ry = NULL; p_system->old_rz = NULL; p_system->old_fx = NULL; p_system->old_fy = NULL; p_system->old_fz = NULL; p_system->sx = NULL; p_system->sy = NULL; p_system->sz = NULL; free(p_topol->nonbonded_param); free(data_nonbonded); p_topol->nonbonded_param = NULL; data_nonbonded = NULL; free(p_task); free(p_system); free(p_topol); free(p_metal); free(p_runset); p_task = NULL; p_system = NULL; p_topol = NULL; p_metal = NULL; p_runset = NULL; ierr = MPI_Finalize(); if (ierr) {} return 0; }
static void time_integration_loop(Forceinfo *fi, Nbodyinfo *nb) { int i, nstep; int outsnapstep, outimagestep; double W, K, E0, E, Q; double cm[3], cmv[3]; double t = tstart; nstep = (int)((tend-tstart)/dt+0.1); dt = (tend-tstart)/nstep; outsnapstep = (int) (dtsnapout/dt+0.1); outimagestep = (int) (dtimageout/dt+0.1); PR(tstart,f); PR(tend,f); PR(dt,f); PRL(dtsnapout,f); PRL(dtimageout,f); if (cputime_flag) { vtc_turnon_cputime(); } vtc_init_cputime(); vtc_print_cputime("initial vtc_get_force start at"); #if DIRECT /* direct sum */ if (grape_flag) { vtc_set_scale(512.0, nb->m[0]); #if MDGRAPE2 fi->calculator = GRAPE_FORCEONLY; #else fi->calculator = GRAPE; #endif /* MDGRAPE2 */ vtc_get_force_direct(fi, nb); #if CALCPOTENTIAL && MDGRAPE2 fi->calculator = GRAPE_POTENTIALONLY; vtc_get_force_direct(fi, nb); fi->calculator = GRAPE_FORCEONLY; #endif /* CALCPOTENTIAL && MDGRAPE2 */ } else { #if CALCPOTENTIAL fi->calculator = HOST; #endif /* CALCPOTENTIAL */ vtc_get_force_direct(fi, nb); } #else /* tree */ if (grape_flag) { #if NOFORCE fi->calculator = NOCALCULATOR; #elif MDGRAPE2 fi->calculator = GRAPE_FORCEONLY; #else fi->calculator = GRAPE; #endif /* NOFORCE */ vtc_get_force_tree(fi, nb); #if CALCPOTENTIAL && MDGRAPE2 fi->calculator = GRAPE_POTENTIALONLY; vtc_get_force_tree(fi, nb); fi->calculator = GRAPE_FORCEONLY; #endif /* CALCPOTENTIAL && MDGRAPE2 */ } else { #if CALCPOTENTIAL fi->calculator = HOST; #endif /* CALCPOTENTIAL */ vtc_get_force_tree(fi, nb); } #endif vtc_print_cputime("initial vtc_get_force end at"); fprintf(stderr, "ninteraction: %e list_len_avg: %6.5f nwalk: %d\n", fi->ninteraction, (double)fi->ninteraction/nb->n, fi->nwalk); K = get_kinetic_energy(nb); #if CALCPOTENTIAL W = get_potential_energy(nb); E = E0 = W+K; PR(E0, 20.17f); PR(W, 20.17f); #endif PRL(K, f); plot_nbody(t, nb); /* calculate force at T=0 and quit */ if (snapout_flag && dtsnapout == 0.0) { static int nout = 0; char fn[255]; snapout_acc_flag = 1; sprintf(fn, snapoutfile, nout); PRL(fn, s); if (ionemo_flag) { write_binary(fn, t, nb); } else if (usepob_flag) { write_pob(fn, t, nb); } else { write_ascii(fn, t, nb); } vtc_print_cputime("exit at"); #if USE_GM_API fprintf(stderr, "will m2_gm_finalize...\n"); m2_gm_finalize(); fprintf(stderr, "done m2_gm_finalize.\n"); #endif /* USE_GM_API */ } for (i = 0; i < nstep; i++) { if (i%outlogstep == outlogstep - 1 && cputime_flag) { vtc_turnon_cputime(); } else { vtc_turnoff_cputime(); } fprintf(stderr, "step %d\n", i); push_velocity(0.5*dt, nb); push_position(dt, nb); t = tstart+(i+1)*dt; vtc_init_cputime(); #if DIRECT /* direct sum */ vtc_get_force_direct(fi, nb); #else /* tree */ vtc_get_force_tree(fi, nb); #endif vtc_print_cputime("vtc_get_force end at"); push_velocity(0.5*dt, nb); vtc_print_cputime("integration end at"); plot_nbody(t, nb); if (i%outlogstep == outlogstep - 1) { fprintf(stderr, "ninteraction: %e list_len_avg: %6.5f nwalk: %d\n", fi->ninteraction, fi->ninteraction/nb->n, fi->nwalk); K = get_kinetic_energy(nb); #if CALCPOTENTIAL #if MDGRAPE2 if (grape_flag) { fi->calculator = GRAPE_POTENTIALONLY; #if DIRECT /* direct sum */ vtc_get_force_direct(fi, nb); #else /* tree */ vtc_get_force_tree(fi, nb); #endif /* direct/tree */ fi->calculator = GRAPE_FORCEONLY; } #endif /* MDGRAPE2 */ W = get_potential_energy(nb); E = W+K; Q = K/(K-E); fprintf(stderr, "\nT= %f K= %20.17f Q= %20.17f E= %20.17f Eerr= %20.17f Eabserr= %20.17f\n", t, K, Q, E, (E0-E)/E0, E0-E); #else /* CALCPOTENTIAL */ fprintf(stderr, "\nT= %f K= %20.17f\n", t, K); #endif /* CALCPOTENTIAL */ fprintf(stderr, "step: %d\n", i); get_cmterms(nb, cm, cmv); fprintf(stderr, "CM %15.13e %15.13e %15.13e\n", cm[0], cm[1], cm[2]); fprintf(stderr, "CMV %15.13e %15.13e %15.13e\n", cmv[0], cmv[1], cmv[2]); } if (i%outsnapstep == outsnapstep - 1 && snapout_flag) { static int nout = 0; char fn[255]; char cmd[255]; sprintf(fn, snapoutfile, nout); PRL(fn, s); if (ionemo_flag) { write_binary(fn, t, nb); } else if (usepob_flag) { write_pob(fn, t, nb); } else { write_ascii(fn, t, nb); } if (command_exec_flag) { sprintf(cmd, "%s %s %03d", command_name, fn, nout); fprintf(stderr, "execute %s\n", cmd); system(cmd); } nout++; PR(t, f); PRL(fn, s); } if (i%outimagestep == outimagestep - 1 && imageout_flag) { static int nout = 0; char fn[255]; char cmd[255]; char msg[255]; double center[2]; sprintf(fn, snapoutfile, nout); strcat(fn, ".gif"); PRL(fn, s); sprintf(msg, "t: %5.3f", t); center[0] = 0.0; center[1] = 0.0; // vtc_plotstar(fn, nb, msg, image_scale, center, 1e10, NULL, NULL); // vtc_plotstar(nb->x, nb->m, nb->n, t, image_scale, fn); nout++; PR(t, f); PRL(fn, s); } vtc_print_cputime("exit at"); } /* i loop */ }
// program entry point int main(int argc, char* argv[]) { int option_index = 0, c, i; char* progname = argv[0]; static const char* getopt_string = "gvhlt:p:f:bs:"; static struct option long_options[] = { {"version", 0,0,'v'}, {"help", 0,0,'h'}, {"list", 0,0,'l'}, {"template-file", 1,0,'t'}, {"project", 1,0,'p'}, {"flavor", 1,0,'f'}, {"write-binary", 0,0,'b'}, {"snippet", 1,0,'s'}, {"git", 0,0,'g'}, {0,0,0,0} }; // select default template file in homedir std::string homedir = sysdep_get_homedir(); option_template_file = homedir + "/" + DEFAULT_TEMPLATE_FILE; while ((c = getopt_long(argc, argv, getopt_string, long_options, &option_index)) != EOF) { switch (c) { case 'v': /* version */ std::cout << progname << " (GNU " << PACKAGE_NAME << ") " << PACKAGE_VERSION << "\n\n" << _( "Copyright (C) 2009 Bert van der Weerd.\n" "This is free software; see the source for copying conditions. There is NO\n" "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" "\nThis program is dedicated to the loving memory of KaleGek, my friend.\n" ) ; return 0; case 'h': /* help */ help: std::cout << "Generate text source files and projects from a standard template.\n" "\n" "Usage: sprot [-f FLAVOR] FILE...\n" " sprot -l\n" " sprot -p PROJECT NAME...\n" " sprot -b FILE...\n" " sprot -s SNIPPET\n" "\n" " -g, --git Create git repository, set $(name) and $(email), check in files.\n" "\n" " -b,--write-binary Write input files to standard output as a hexadecimal dump\n" " -f FLAVOR, --flavor=FLAVOR Specify template flavor for a specific template extension\n" " -h, --help Display this help and exit\n" " -l, --list Display contents of the template file\n" " -p PROJECT, --project=PROJECT Select PROJECT from template file and generate it under name of FILE\n" " -s SNIPPET, --snippet=SNIPPET Print SNIPPET on stdout.\n" " -t FILE, --template-file=FILE Use FILE as template file (works with any sprot invocation)\n" " -v, --version Display version information and exit\n" "\n" "Please report bugs and ideas to <" << PACKAGE_BUGREPORT << ">.\n" ; return 0; case 'g': option_do_git = true; break; case 'l': // list option_list = true; break; case 'b': option_write_binary = true; break; case 't': option_template_file = std::string(optarg); break; case 'p': option_project_mode = true; option_project_name = std::string(optarg); break; case 's': option_snippet_mode = true; option_snippet_name = std::string(optarg); case 'f': option_flavor = std::string(optarg); break; default: /* getopt() returned invalid value */ return 1; } } if (option_list && option_write_binary) { std::cerr << progname << _(": Cannot specify option -b and -l at the same time.") << std::endl; return 1; } if (option_write_binary) { if (optind == argc) { std::cerr << progname << _(": Please specify one or more files to write out as binary.") << std::endl; return 1; } else for (int i = optind; i < argc; i++) if (write_binary(argv[i]) != 0) return 1; return 0; } if (option_list) { if (optind != argc) std::cerr << progname << _(": Cannot have arguments when specifying -l option (list template file)") << std::endl; else { sprot_datafile datafile; try { datafile.parse(option_template_file); } catch (std::exception& ex) { std::cerr << option_template_file << ": " << ex.what() << std::endl; return 1; } list_sprotfile_contents(datafile); } return 0; } if (optind == argc && !option_snippet_mode) goto help; // read the sprot datafile sprot_datafile datafile; try { datafile.parse(option_template_file); } catch (std::exception& ex) { std::cerr << option_template_file << ": " << ex.what() << std::endl; return 1; } // the actual work if (option_project_mode) { for(i = optind; i < argc; i++) { int retval = generate_project_initial(datafile,option_project_name,argv[i]); if (retval) return retval; } } else if (option_snippet_mode) { if (option_snippet_name == "") { std::cerr << progname << ": The snippet name cannot be empty." << std::endl; return 1; } int retval = generate_snippet_to_stdout(datafile,option_snippet_name); return retval; } else { for (i = optind; i < argc; i++) { int retval = generate_file_initial(datafile,option_flavor,argv[i]); if (retval) return retval; } } return 0; }