int main(int argc, char **argv)
{
int i;
#ifdef NEED_ARGV_FIXUP
argv_fixup( &argc, &argv );
#endif
flexinit( argc, argv );
readin();
ntod();
for ( i = 1; i <= num_rules; ++i )
if ( ! rule_useful[i] && i != default_rule )
line_warning( _( "rule cannot be matched" ),
rule_linenum[i] );
if ( spprdflt && ! reject && rule_useful[default_rule] )
line_warning(
_( "-s option given but default rule can be matched" ),
rule_linenum[default_rule] );
/* Generate the C state transition tables from the DFA. */
make_tables();
/* Note, flexend does not return. It exits with its argument
* as status.
*/
flexend( 0 );
return 0; /* keep compilers/lint happy */
}
int main(int argc, char const *argv[])
{
LOGI(WELCOME_MESSAGE);
make_tables((unsigned char *)PASSWORD, encrypt_table, decrypt_table);
LOGI("Encrypt and decrypt table generated");
int n;
uv_loop_t *loop = uv_default_loop();
uv_tcp_t listener;
struct sockaddr_in addr = uv_ip4_addr(SERVER_LISTEN, SERVER_PORT);
n = uv_tcp_init(loop, &listener);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
n = uv_tcp_bind(&listener, addr);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
n = uv_listen((uv_stream_t*)(void *)&listener, 5, connect_cb);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
LOGI("Listening on " SERVER_LISTEN ":" TOSTR(SERVER_PORT));
return uv_run(loop);
}
int flex_main (int argc, char *argv[])
{
int i, exit_status, child_status;
/* Set a longjmp target. Yes, I know it's a hack, but it gets worse: The
* return value of setjmp, if non-zero, is the desired exit code PLUS ONE.
* For example, if you want 'main' to return with code '2', then call
* longjmp() with an argument of 3. This is because it is invalid to
* specify a value of 0 to longjmp. FLEX_EXIT(n) should be used instead of
* exit(n);
*/
exit_status = setjmp (flex_main_jmp_buf);
if (exit_status){
if (stdout && !_stdout_closed && !ferror(stdout)){
fflush(stdout);
fclose(stdout);
}
while (wait(&child_status) > 0){
if (!WIFEXITED (child_status)
|| WEXITSTATUS (child_status) != 0){
/* report an error of a child
*/
if( exit_status <= 1 )
exit_status = 2;
}
}
return exit_status - 1;
}
flexinit (argc, argv);
readin ();
skelout ();
/* %% [1.5] DFA */
ntod ();
for (i = 1; i <= num_rules; ++i)
if (!rule_useful[i] && i != default_rule)
line_warning (_("rule cannot be matched"),
rule_linenum[i]);
if (spprdflt && !reject && rule_useful[default_rule])
line_warning (_
("-s option given but default rule can be matched"),
rule_linenum[default_rule]);
/* Generate the C state transition tables from the DFA. */
make_tables ();
/* Note, flexend does not return. It exits with its argument
* as status.
*/
flexend (0);
return 0; /* keep compilers/lint happy */
}
void make_wall_tables(FILE *fplog,
const t_inputrec *ir, const char *tabfn,
const gmx_groups_t *groups,
t_forcerec *fr)
{
int negp_pp;
int *nm_ind;
char buf[STRLEN];
negp_pp = ir->opts.ngener - ir->nwall;
nm_ind = groups->grps[egcENER].nm_ind;
if (fplog)
{
fprintf(fplog, "Reading user tables for %d energy groups with %d walls\n",
negp_pp, ir->nwall);
}
snew(fr->wall_tab, ir->nwall);
for (int w = 0; w < ir->nwall; w++)
{
snew(fr->wall_tab[w], negp_pp);
for (int egp = 0; egp < negp_pp; egp++)
{
/* If the energy group pair is excluded, we don't need a table */
if (!(fr->egp_flags[egp*ir->opts.ngener+negp_pp+w] & EGP_EXCL))
{
fr->wall_tab[w][egp] = make_tables(fplog, fr, buf, 0,
GMX_MAKETABLES_FORCEUSER);
sprintf(buf, "%s", tabfn);
sprintf(buf + strlen(tabfn) - strlen(ftp2ext(efXVG)) - 1, "_%s_%s.%s",
*groups->grpname[nm_ind[egp]],
*groups->grpname[nm_ind[negp_pp+w]],
ftp2ext(efXVG));
/* Since wall have no charge, we can compress the table */
for (int i = 0; i <= fr->wall_tab[w][egp]->n; i++)
{
for (int j = 0; j < 8; j++)
{
fr->wall_tab[w][egp]->data[8*i+j] =
fr->wall_tab[w][egp]->data[12*i+4+j];
}
}
}
}
}
}
int main(int argc,char *argv[])
{
t_forcerec *fr;
rvec box;
fr=mk_forcerec();
fr->r1 = 0.6;
fr->rc = 0.9;
fr->eeltype = eelTWIN;
box[XX]=box[YY]=box[ZZ]=1.0;
set_shift_consts(stdout,fr->r1,fr->rc,box,fr);
make_tables(fr);
return 0;
}
int test_stripes(int *source, unsigned long long *offsets,
int raid_disks, int chunk_size, int level, int layout,
unsigned long long start, unsigned long long length)
{
/* ready the data and p (and q) blocks, and check we got them right */
char *stripe_buf = xmalloc(raid_disks * chunk_size);
char **stripes = xmalloc(raid_disks * sizeof(char*));
char **blocks = xmalloc(raid_disks * sizeof(char*));
char *p = xmalloc(chunk_size);
char *q = xmalloc(chunk_size);
int i;
int diskP, diskQ;
int data_disks = raid_disks - (level == 5 ? 1: 2);
if (!tables_ready)
make_tables();
for ( i = 0 ; i < raid_disks ; i++)
stripes[i] = stripe_buf + i * chunk_size;
while (length > 0) {
int disk;
for (i = 0 ; i < raid_disks ; i++) {
lseek64(source[i], offsets[i]+start, 0);
read(source[i], stripes[i], chunk_size);
}
for (i = 0 ; i < data_disks ; i++) {
int disk = geo_map(i, start/chunk_size, raid_disks,
level, layout);
blocks[i] = stripes[disk];
printf("%d->%d\n", i, disk);
}
switch(level) {
case 6:
qsyndrome(p, q, (uint8_t**)blocks, data_disks, chunk_size);
diskP = geo_map(-1, start/chunk_size, raid_disks,
level, layout);
if (memcmp(p, stripes[diskP], chunk_size) != 0) {
printf("P(%d) wrong at %llu\n", diskP,
start / chunk_size);
}
diskQ = geo_map(-2, start/chunk_size, raid_disks,
level, layout);
if (memcmp(q, stripes[diskQ], chunk_size) != 0) {
printf("Q(%d) wrong at %llu\n", diskQ,
start / chunk_size);
}
disk = raid6_check_disks(data_disks, start, chunk_size,
level, layout, diskP, diskQ,
p, q, stripes);
if(disk >= 0) {
printf("Possible failed disk: %d\n", disk);
}
if(disk == -2) {
printf("Failure detected, but disk unknown\n");
}
break;
}
length -= chunk_size;
start += chunk_size;
}
return 0;
}
/*******************************************************************************
* Function: save_stripes
* Description:
* Function reads data (only data without P and Q) from array and writes
* it to buf and opcjonaly to backup files
* Parameters:
* source : A list of 'fds' of the active disks.
* Some may be absent
* offsets : A list of offsets on disk belonging
* to the array [bytes]
* raid_disks : geometry: number of disks in the array
* chunk_size : geometry: chunk size [bytes]
* level : geometry: RAID level
* layout : geometry: layout
* nwrites : number of backup files
* dest : A list of 'fds' for mirrored targets
* (e.g. backup files). They are already seeked to right
* (write) location. If NULL, data will be wrote
* to the buf only
* start : start address of data to read (must be stripe-aligned)
* [bytes]
* length - : length of data to read (must be stripe-aligned)
* [bytes]
* buf : buffer for data. It is large enough to hold
* one stripe. It is stripe aligned
* Returns:
* 0 : success
* -1 : fail
******************************************************************************/
int save_stripes(int *source, unsigned long long *offsets,
int raid_disks, int chunk_size, int level, int layout,
int nwrites, int *dest,
unsigned long long start, unsigned long long length,
char *buf)
{
int len;
int data_disks = raid_disks - (level == 0 ? 0 : level <=5 ? 1 : 2);
int disk;
int i;
unsigned long long length_test;
if (!tables_ready)
make_tables();
ensure_zero_has_size(chunk_size);
len = data_disks * chunk_size;
length_test = length / len;
length_test *= len;
if (length != length_test) {
dprintf("Error: save_stripes(): Data are not alligned. EXIT\n");
dprintf("\tArea for saving stripes (length) = %llu\n", length);
dprintf("\tWork step (len) = %i\n", len);
dprintf("\tExpected save area (length_test) = %llu\n",
length_test);
abort();
}
while (length > 0) {
int failed = 0;
int fdisk[3], fblock[3];
for (disk = 0; disk < raid_disks ; disk++) {
unsigned long long offset;
int dnum;
offset = (start/chunk_size/data_disks)*chunk_size;
dnum = geo_map(disk < data_disks ? disk : data_disks - disk - 1,
start/chunk_size/data_disks,
raid_disks, level, layout);
if (dnum < 0) abort();
if (source[dnum] < 0 ||
lseek64(source[dnum], offsets[dnum]+offset, 0) < 0 ||
read(source[dnum], buf+disk * chunk_size, chunk_size)
!= chunk_size)
if (failed <= 2) {
fdisk[failed] = dnum;
fblock[failed] = disk;
failed++;
}
}
if (failed == 0 || fblock[0] >= data_disks)
/* all data disks are good */
;
else if (failed == 1 || fblock[1] >= data_disks+1) {
/* one failed data disk and good parity */
char *bufs[data_disks];
for (i=0; i < data_disks; i++)
if (fblock[0] == i)
bufs[i] = buf + data_disks*chunk_size;
else
bufs[i] = buf + i*chunk_size;
xor_blocks(buf + fblock[0]*chunk_size,
bufs, data_disks, chunk_size);
} else if (failed > 2 || level != 6)
/* too much failure */
return -1;
else {
/* RAID6 computations needed. */
uint8_t *bufs[data_disks+4];
int qdisk;
int syndrome_disks;
disk = geo_map(-1, start/chunk_size/data_disks,
raid_disks, level, layout);
qdisk = geo_map(-2, start/chunk_size/data_disks,
raid_disks, level, layout);
if (is_ddf(layout)) {
/* q over 'raid_disks' blocks, in device order.
* 'p' and 'q' get to be all zero
*/
for (i = 0; i < raid_disks; i++)
bufs[i] = zero;
for (i = 0; i < data_disks; i++) {
int dnum = geo_map(i,
start/chunk_size/data_disks,
raid_disks, level, layout);
int snum;
/* i is the logical block number, so is index to 'buf'.
* dnum is physical disk number
* and thus the syndrome number.
*/
snum = dnum;
bufs[snum] = (uint8_t*)buf + chunk_size * i;
}
syndrome_disks = raid_disks;
} else {
/* for md, q is over 'data_disks' blocks,
* starting immediately after 'q'
* Note that for the '_6' variety, the p block
* makes a hole that we need to be careful of.
*/
int j;
int snum = 0;
for (j = 0; j < raid_disks; j++) {
int dnum = (qdisk + 1 + j) % raid_disks;
if (dnum == disk || dnum == qdisk)
continue;
for (i = 0; i < data_disks; i++)
if (geo_map(i,
start/chunk_size/data_disks,
raid_disks, level, layout) == dnum)
break;
/* i is the logical block number, so is index to 'buf'.
* dnum is physical disk number
* snum is syndrome disk for which 0 is immediately after Q
*/
bufs[snum] = (uint8_t*)buf + chunk_size * i;
if (fblock[0] == i)
fdisk[0] = snum;
if (fblock[1] == i)
fdisk[1] = snum;
snum++;
}
syndrome_disks = data_disks;
}
/* Place P and Q blocks at end of bufs */
bufs[syndrome_disks] = (uint8_t*)buf + chunk_size * data_disks;
bufs[syndrome_disks+1] = (uint8_t*)buf + chunk_size * (data_disks+1);
if (fblock[1] == data_disks)
/* One data failed, and parity failed */
raid6_datap_recov(syndrome_disks+2, chunk_size,
fdisk[0], bufs, 0);
else {
/* Two data blocks failed, P,Q OK */
raid6_2data_recov(syndrome_disks+2, chunk_size,
fdisk[0], fdisk[1], bufs, 0);
}
}
if (dest) {
for (i = 0; i < nwrites; i++)
if (write(dest[i], buf, len) != len)
return -1;
} else {
/* build next stripe in buffer */
buf += len;
}
length -= len;
start += len;
}
return 0;
}
int main(int argc, char *argv[])
{
flexinit( argc, argv );
readin();
if ( syntaxerror )
flexend( 1 );
if ( yymore_really_used == REALLY_USED )
yymore_used = true;
else if ( yymore_really_used == REALLY_NOT_USED )
yymore_used = false;
if ( reject_really_used == REALLY_USED )
reject = true;
else if ( reject_really_used == REALLY_NOT_USED )
reject = false;
if ( performance_report )
{
if ( interactive )
fprintf( stderr,
"-I (interactive) entails a minor performance penalty\n" );
if ( yymore_used )
fprintf( stderr, "yymore() entails a minor performance penalty\n" );
if ( reject )
fprintf( stderr, "REJECT entails a large performance penalty\n" );
if ( variable_trailing_context_rules )
fprintf( stderr,
"Variable trailing context rules entail a large performance penalty\n" );
}
if ( reject )
real_reject = true;
if ( variable_trailing_context_rules )
reject = true;
if ( (fulltbl || fullspd) && reject )
{
if ( real_reject )
flexerror( "REJECT cannot be used with -f or -F" );
else
flexerror(
"variable trailing context rules cannot be used with -f or -F" );
}
ntod();
/* generate the C state transition tables from the DFA */
make_tables();
/* note, flexend does not return. It exits with its argument as status. */
flexend( 0 );
/*NOTREACHED*/
}
int check_stripes(struct mdinfo *info, int *source, unsigned long long *offsets,
int raid_disks, int chunk_size, int level, int layout,
unsigned long long start, unsigned long long length, char *name[],
int repair, int failed_disk1, int failed_disk2)
{
/* read the data and p and q blocks, and check we got them right */
char *stripe_buf = xmalloc(raid_disks * chunk_size);
char **stripes = xmalloc(raid_disks * sizeof(char*));
char **blocks = xmalloc(raid_disks * sizeof(char*));
int *block_index_for_slot = xmalloc(raid_disks * sizeof(int));
uint8_t *p = xmalloc(chunk_size);
uint8_t *q = xmalloc(chunk_size);
int *results = xmalloc(chunk_size * sizeof(int));
sighandler_t *sig = xmalloc(3 * sizeof(sighandler_t));
int i;
int diskP, diskQ;
int data_disks = raid_disks - 2;
int err = 0;
extern int tables_ready;
if (!tables_ready)
make_tables();
for ( i = 0 ; i < raid_disks ; i++)
stripes[i] = stripe_buf + i * chunk_size;
while (length > 0) {
int disk;
printf("pos --> %llu\n", start);
err = lock_stripe(info, start, chunk_size, data_disks, sig);
if(err != 0) {
if (err != 2)
unlock_all_stripes(info, sig);
goto exitCheck;
}
for (i = 0 ; i < raid_disks ; i++) {
lseek64(source[i], offsets[i] + start * chunk_size, 0);
read(source[i], stripes[i], chunk_size);
}
err = unlock_all_stripes(info, sig);
if(err != 0)
goto exitCheck;
for (i = 0 ; i < data_disks ; i++) {
int disk = geo_map(i, start, raid_disks, level, layout);
blocks[i] = stripes[disk];
block_index_for_slot[disk] = i;
printf("%d->%d\n", i, disk);
}
qsyndrome(p, q, (uint8_t**)blocks, data_disks, chunk_size);
diskP = geo_map(-1, start, raid_disks, level, layout);
diskQ = geo_map(-2, start, raid_disks, level, layout);
blocks[data_disks] = stripes[diskP];
block_index_for_slot[diskP] = data_disks;
blocks[data_disks+1] = stripes[diskQ];
block_index_for_slot[diskQ] = data_disks+1;
if (memcmp(p, stripes[diskP], chunk_size) != 0) {
printf("P(%d) wrong at %llu\n", diskP, start);
}
if (memcmp(q, stripes[diskQ], chunk_size) != 0) {
printf("Q(%d) wrong at %llu\n", diskQ, start);
}
raid6_collect(chunk_size, p, q, stripes[diskP], stripes[diskQ], results);
disk = raid6_stats(results, raid_disks, chunk_size);
if(disk >= -2) {
disk = geo_map(disk, start, raid_disks, level, layout);
}
if(disk >= 0) {
printf("Error detected at %llu: possible failed disk slot: %d --> %s\n",
start, disk, name[disk]);
}
if(disk == -65535) {
printf("Error detected at %llu: disk slot unknown\n", start);
}
if(repair == 1) {
printf("Repairing stripe %llu\n", start);
printf("Assuming slots %d (%s) and %d (%s) are incorrect\n",
failed_disk1, name[failed_disk1],
failed_disk2, name[failed_disk2]);
if (failed_disk1 == diskQ || failed_disk2 == diskQ) {
char *all_but_failed_blocks[data_disks];
int failed_data_or_p;
int failed_block_index;
if (failed_disk1 == diskQ)
failed_data_or_p = failed_disk2;
else
failed_data_or_p = failed_disk1;
printf("Repairing D/P(%d) and Q\n", failed_data_or_p);
failed_block_index = block_index_for_slot[failed_data_or_p];
for (i=0; i < data_disks; i++)
if (failed_block_index == i)
all_but_failed_blocks[i] = stripes[diskP];
else
all_but_failed_blocks[i] = blocks[i];
xor_blocks(stripes[failed_data_or_p],
all_but_failed_blocks, data_disks, chunk_size);
qsyndrome(p, (uint8_t*)stripes[diskQ], (uint8_t**)blocks, data_disks, chunk_size);
} else {
ensure_zero_has_size(chunk_size);
if (failed_disk1 == diskP || failed_disk2 == diskP) {
int failed_data, failed_block_index;
if (failed_disk1 == diskP)
failed_data = failed_disk2;
else
failed_data = failed_disk1;
failed_block_index = block_index_for_slot[failed_data];
printf("Repairing D(%d) and P\n", failed_data);
raid6_datap_recov(raid_disks, chunk_size, failed_block_index, (uint8_t**)blocks);
} else {
printf("Repairing D and D\n");
int failed_block_index1 = block_index_for_slot[failed_disk1];
int failed_block_index2 = block_index_for_slot[failed_disk2];
if (failed_block_index1 > failed_block_index2) {
int t = failed_block_index1;
failed_block_index1 = failed_block_index2;
failed_block_index2 = t;
}
raid6_2data_recov(raid_disks, chunk_size, failed_block_index1, failed_block_index2, (uint8_t**)blocks);
}
}
err = lock_stripe(info, start, chunk_size, data_disks, sig);
if(err != 0) {
if (err != 2)
unlock_all_stripes(info, sig);
goto exitCheck;
}
lseek64(source[failed_disk1], offsets[failed_disk1] + start * chunk_size, 0);
write(source[failed_disk1], stripes[failed_disk1], chunk_size);
lseek64(source[failed_disk2], offsets[failed_disk2] + start * chunk_size, 0);
write(source[failed_disk2], stripes[failed_disk2], chunk_size);
err = unlock_all_stripes(info, sig);
if(err != 0)
goto exitCheck;
} else if (disk >= 0 && repair == 2) {
printf("Auto-repairing slot %d (%s)\n", disk, name[disk]);
if (disk == diskQ) {
qsyndrome(p, (uint8_t*)stripes[diskQ], (uint8_t**)blocks, data_disks, chunk_size);
} else {
char *all_but_failed_blocks[data_disks];
int failed_block_index = block_index_for_slot[disk];
for (i=0; i < data_disks; i++)
if (failed_block_index == i)
all_but_failed_blocks[i] = stripes[diskP];
else
all_but_failed_blocks[i] = blocks[i];
xor_blocks(stripes[disk],
all_but_failed_blocks, data_disks, chunk_size);
}
err = lock_stripe(info, start, chunk_size, data_disks, sig);
if(err != 0) {
if (err != 2)
unlock_all_stripes(info, sig);
goto exitCheck;
}
lseek64(source[disk], offsets[disk] + start * chunk_size, 0);
write(source[disk], stripes[disk], chunk_size);
err = unlock_all_stripes(info, sig);
if(err != 0)
goto exitCheck;
}
length--;
start++;
}
exitCheck:
free(stripe_buf);
free(stripes);
free(blocks);
free(p);
free(q);
free(results);
return err;
}
void init_forcerec(FILE *fp,
t_forcerec *fr,
t_inputrec *ir,
t_topology *top,
t_commrec *cr,
t_mdatoms *mdatoms,
t_nsborder *nsb,
matrix box,
bool bMolEpot,
char *tabfn,
bool bNoSolvOpt)
{
int i,j,m,natoms,ngrp,tabelemsize;
real q,zsq,nrdf,T;
rvec box_size;
double rtab;
t_block *mols,*cgs;
t_idef *idef;
if (check_box(box))
fatal_error(0,check_box(box));
cgs = &(top->blocks[ebCGS]);
mols = &(top->blocks[ebMOLS]);
idef = &(top->idef);
natoms = mdatoms->nr;
/* Shell stuff */
fr->fc_stepsize = ir->fc_stepsize;
/* Free energy */
fr->efep = ir->efep;
fr->sc_alpha = ir->sc_alpha;
fr->sc_sigma6 = pow(ir->sc_sigma,6);
/* Neighbour searching stuff */
fr->bGrid = (ir->ns_type == ensGRID);
fr->ndelta = ir->ndelta;
fr->ePBC = ir->ePBC;
fr->rlist = ir->rlist;
fr->rlistlong = max(ir->rlist,max(ir->rcoulomb,ir->rvdw));
fr->eeltype = ir->coulombtype;
fr->vdwtype = ir->vdwtype;
fr->bTwinRange = fr->rlistlong > fr->rlist;
fr->bEwald = fr->eeltype==eelPME || fr->eeltype==eelEWALD;
fr->bvdwtab = fr->vdwtype != evdwCUT;
fr->bRF = (fr->eeltype==eelRF || fr->eeltype==eelGRF) &&
fr->vdwtype==evdwCUT;
fr->bcoultab = (fr->eeltype!=eelCUT && !fr->bRF) || fr->bEwald;
#ifndef SPEC_CPU
if (getenv("GMX_FORCE_TABLES")) {
fr->bvdwtab = TRUE;
fr->bcoultab = TRUE;
}
#endif
if (fp) {
fprintf(fp,"Table routines are used for coulomb: %s\n",bool_names[fr->bcoultab]);
fprintf(fp,"Table routines are used for vdw: %s\n",bool_names[fr->bvdwtab ]);
}
/* Tables are used for direct ewald sum */
if(fr->bEwald) {
fr->ewaldcoeff=calc_ewaldcoeff(ir->rcoulomb, ir->ewald_rtol);
if (fp)
fprintf(fp,"Using a Gaussian width (1/beta) of %g nm for Ewald\n",
1/fr->ewaldcoeff);
}
/* Domain decomposition parallellism... */
fr->bDomDecomp = ir->bDomDecomp;
fr->Dimension = ir->decomp_dir;
/* Electrostatics */
fr->epsilon_r = ir->epsilon_r;
fr->fudgeQQ = ir->fudgeQQ;
fr->rcoulomb_switch = ir->rcoulomb_switch;
fr->rcoulomb = ir->rcoulomb;
#ifndef SPEC_CPU
if (bNoSolvOpt || getenv("GMX_NO_SOLV_OPT"))
fr->bSolvOpt = FALSE;
else
#endif
fr->bSolvOpt = TRUE;
/* Parameters for generalized RF */
fr->zsquare = 0.0;
fr->temp = 0.0;
if (fr->eeltype == eelGRF) {
zsq = 0.0;
for (i=0; (i<cgs->nr); i++) {
q = 0;
for(j=cgs->index[i]; (j<cgs->index[i+1]); j++)
q+=mdatoms->chargeT[cgs->a[j]];
if (fabs(q) > GMX_REAL_MIN)
/* Changed from square to fabs 990314 DvdS
* Does not make a difference for monovalent ions, but doe for
* divalent ions (Ca2+!!)
*/
zsq += fabs(q);
}
fr->zsquare = zsq;
T = 0.0;
nrdf = 0.0;
for(i=0; (i<ir->opts.ngtc); i++) {
nrdf += ir->opts.nrdf[i];
T += (ir->opts.nrdf[i] * ir->opts.ref_t[i]);
}
if (nrdf < GMX_REAL_MIN)
fatal_error(0,"No degrees of freedom!");
fr->temp = T/nrdf;
}
else if (EEL_LR(fr->eeltype) || (fr->eeltype == eelSHIFT) ||
(fr->eeltype == eelUSER) || (fr->eeltype == eelSWITCH)) {
/* We must use the long range cut-off for neighboursearching...
* An extra range of e.g. 0.1 nm (half the size of a charge group)
* is necessary for neighboursearching. This allows diffusion
* into the cut-off range (between neighborlist updates),
* and gives more accurate forces because all atoms within the short-range
* cut-off rc must be taken into account, while the ns criterium takes
* only those with the center of geometry within the cut-off.
* (therefore we have to add half the size of a charge group, plus
* something to account for diffusion if we have nstlist > 1)
*/
for(m=0; (m<DIM); m++)
box_size[m]=box[m][m];
if (fr->phi == NULL)
snew(fr->phi,mdatoms->nr);
if ((fr->eeltype==eelPPPM) || (fr->eeltype==eelPOISSON) ||
(fr->eeltype == eelSHIFT && fr->rcoulomb > fr->rcoulomb_switch))
set_shift_consts(fp,fr->rcoulomb_switch,fr->rcoulomb,box_size,fr);
}
/* Initiate arrays */
if (fr->bTwinRange) {
snew(fr->f_twin,natoms);
snew(fr->fshift_twin,SHIFTS);
}
if (EEL_LR(fr->eeltype)) {
snew(fr->f_pme,natoms);
}
/* Mask that says whether or not this NBF list should be computed */
/* if (fr->bMask == NULL) {
ngrp = ir->opts.ngener*ir->opts.ngener;
snew(fr->bMask,ngrp);*/
/* Defaults to always */
/* for(i=0; (i<ngrp); i++)
fr->bMask[i] = TRUE;
}*/
if (fr->cg_cm == NULL)
snew(fr->cg_cm,cgs->nr);
if (fr->shift_vec == NULL)
snew(fr->shift_vec,SHIFTS);
if (fr->fshift == NULL)
snew(fr->fshift,SHIFTS);
if (bMolEpot && (fr->nmol==0)) {
fr->nmol=mols->nr;
fr->mol_nr=make_invblock(mols,natoms);
snew(fr->mol_epot,fr->nmol);
fr->nstcalc=ir->nstenergy;
}
if (fr->nbfp == NULL) {
fr->ntype = idef->atnr;
fr->bBHAM = (idef->functype[0] == F_BHAM);
fr->nbfp = mk_nbfp(idef,fr->bBHAM);
}
/* Copy the energy group exclusions */
fr->eg_excl = ir->opts.eg_excl;
/* Van der Waals stuff */
fr->rvdw = ir->rvdw;
fr->rvdw_switch = ir->rvdw_switch;
if ((fr->vdwtype != evdwCUT) && (fr->vdwtype != evdwUSER) && !fr->bBHAM) {
if (fr->rvdw_switch >= fr->rvdw)
fatal_error(0,"rvdw_switch (%g) must be < rvdw (%g)",
fr->rvdw_switch,fr->rvdw);
if (fp)
fprintf(fp,"Using %s Lennard-Jones, switch between %g and %g nm\n",
(fr->eeltype==eelSWITCH) ? "switched":"shifted",
fr->rvdw_switch,fr->rvdw);
}
if (fp)
fprintf(fp,"Cut-off's: NS: %g Coulomb: %g %s: %g\n",
fr->rlist,fr->rcoulomb,fr->bBHAM ? "BHAM":"LJ",fr->rvdw);
if (ir->eDispCorr != edispcNO)
set_avcsix(fp,fr,mdatoms);
if (fr->bBHAM)
set_bham_b_max(fp,fr,mdatoms);
/* Now update the rest of the vars */
update_forcerec(fp,fr,box);
/* if we are using LR electrostatics, and they are tabulated,
* the tables will contain shifted coulomb interactions.
* Since we want to use the non-shifted ones for 1-4
* coulombic interactions, we must have an extra set of
* tables. This should be done in tables.c, instead of this
* ugly hack, but it works for now...
*/
#define MAX_14_DIST 1.0
/* Shell to account for the maximum chargegroup radius (2*0.2 nm) *
* and diffusion during nstlist steps (0.2 nm) */
#define TAB_EXT 0.6
/* Construct tables.
* A little unnecessary to make both vdw and coul tables sometimes,
* but what the heck... */
if (fr->bcoultab || fr->bvdwtab) {
if (EEL_LR(fr->eeltype)) {
bool bcoulsave,bvdwsave;
/* generate extra tables for 1-4 interactions only
* fake the forcerec so make_tables thinks it should
* just create the non shifted version
*/
bcoulsave=fr->bcoultab;
bvdwsave=fr->bvdwtab;
fr->bcoultab=FALSE;
fr->bvdwtab=FALSE;
fr->rtab=MAX_14_DIST;
make_tables(fp,fr,MASTER(cr),tabfn);
fr->bcoultab=bcoulsave;
fr->bvdwtab=bvdwsave;
fr->coulvdw14tab=fr->coulvdwtab;
fr->coulvdwtab=NULL;
}
fr->rtab = max(fr->rlistlong+TAB_EXT,MAX_14_DIST);
}
else if (fr->efep != efepNO) {
if (fr->rlistlong < GMX_REAL_MIN) {
char *ptr,*envvar="FEP_TABLE_LENGTH";
fr->rtab = 5;
#ifdef SPEC_CPU
ptr = NULL;
#else
ptr = getenv(envvar);
#endif
if (ptr) {
sscanf(ptr,"%lf",&rtab);
fr->rtab = rtab;
}
if (fp)
fprintf(fp,"\nNote: Setting the free energy table length to %g nm\n"
" You can set this value with the environment variable %s"
"\n\n",fr->rtab,envvar);
}
else
fr->rtab = max(fr->rlistlong+TAB_EXT,MAX_14_DIST);
}
else
fr->rtab = MAX_14_DIST;
/* make tables for ordinary interactions */
make_tables(fp,fr,MASTER(cr),tabfn);
if(!(EEL_LR(fr->eeltype) && (fr->bcoultab || fr->bvdwtab)))
fr->coulvdw14tab=fr->coulvdwtab;
/* Copy the contents of the table to separate coulomb and LJ
* tables too, to improve cache performance.
*/
tabelemsize=fr->bBHAM ? 16 : 12;
snew(fr->coultab,4*(fr->ntab+1)*sizeof(real));
snew(fr->vdwtab,(tabelemsize-4)*(fr->ntab+1)*sizeof(real));
for(i=0; i<=fr->ntab; i++) {
for(j=0; j<4; j++)
fr->coultab[4*i+j]=fr->coulvdwtab[tabelemsize*i+j];
for(j=0; j<tabelemsize-4; j++)
fr->vdwtab[(tabelemsize-4)*i+j]=fr->coulvdwtab[tabelemsize*i+4+j];
}
if (!fr->mno_index)
check_solvent(fp,top,fr,mdatoms,nsb);
}
int main(int argc, char *argv[])
{
char *server_listen = SERVER_LISTEN;
int server_port = SERVER_PORT;
uint8_t *password = (uint8_t *)PASSWORD;
char *pid_path = PID_FILE;
char opt;
while((opt = getopt(argc, argv, "l:p:k:f:")) != -1) { // not portable to windows
switch(opt) {
case 'l':
server_listen = optarg;
break;
case 'p':
server_port = atoi(optarg);
break;
case 'k':
password = malloc(strlen(optarg + 1));
strcpy((char *)password, optarg);
break;
case 'f':
pid_path = optarg;
break;
default:
fprintf(stderr, USAGE, argv[0]);
abort();
}
}
FILE *pid_file = fopen(pid_path, "wb");
if (!pid_file)
FATAL("fopen failed, %s", strerror(errno));
fprintf(pid_file, "%d", getpid());
fclose(pid_file);
char *process_title = malloc(PROCESS_TITLE_LENGTH); // we do not like waste memory
if (!process_title)
FATAL("malloc() failed!");
snprintf(process_title, PROCESS_TITLE_LENGTH, PROCESS_TITLE, server_port);
uv_setup_args(argc, argv);
uv_set_process_title(process_title);
free(process_title);
LOGI(WELCOME_MESSAGE);
make_tables(password, encrypt_table, decrypt_table);
LOGI("Encrypt and decrypt table generated");
int n;
uv_loop_t *loop = uv_default_loop();
uv_tcp_t listener;
struct sockaddr_in addr = uv_ip4_addr(server_listen, server_port);
n = uv_tcp_init(loop, &listener);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
n = uv_tcp_bind(&listener, addr);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
n = uv_listen((uv_stream_t*)(void *)&listener, 5, connect_cb);
if (n)
SHOW_UV_ERROR_AND_EXIT(loop);
LOGI("Listening on %s:%d", server_listen, server_port);
#ifndef NDEBUG
setup_signal_handler(loop);
#endif /* !NDEBUG */
return uv_run(loop);
}
