PRIVATE OSErr renamehelper(ioParam *pb, BOOLEAN async, LONGINT dirid, filekind kind)
{
OSErr err, err1;
btparam btparamrec, btparamrec2;
ioParam npb;
if (!pb->ioNamePtr || indexn((char *)pb->ioNamePtr+1, ':', pb->ioNamePtr[0])
== (char *) pb->ioNamePtr + pb->ioNamePtr[0])
err = pbvolrename(pb, (StringPtr) pb->ioMisc);
else {
err = findvcbandfile(pb, dirid, &btparamrec, &kind, FALSE);
if (err == noErr) {
npb = *pb;
npb.ioNamePtr = (StringPtr) pb->ioMisc;
err = findvcbandfile(&npb, dirid, &btparamrec2, &kind, FALSE);
if (err != fnfErr)
err = dupFNErr;
else {
err = writevcbp(btparamrec.vcbp);
if (err == noErr)
err = btrename(&btparamrec, (StringPtr) pb->ioMisc);
err1 = cleancache(btparamrec.vcbp);
if (err == noErr)
err = err1;
}
}
}
PBRETURN(pb, err);
}
/* parse a range given for LbyR or T from the command line.
* Examples:
* 1) "value" => list = { value, value, 1, SCALE_LIN }
* 2) "start,stop,N" => list = { start, stop, N, SCALE_LIN }
* 3) "start,stop,N,log" => list = { start, stop, N, SCALE_LOG }
*/
void parse_range(const char param, const char *_optarg, double list[])
{
int elems = cinstr(_optarg, ','); /* commas in _optarg */
list[3] = SCALE_LIN;
switch(elems)
{
case 0:
/* no comma => example 1) */
list[0] = list[1] = atof(_optarg);
list[2] = 1;
break;
case 3:
/* 3 commas => example 3) */
if(strncasecmp(indexn(_optarg, ',', 3)+1, "log", 3) == 0)
list[3] = SCALE_LOG;
/* here no break! */
case 2:
/* 2 commas => example 2) */
list[0] = atof(_optarg);
list[1] = atof(indexn(_optarg, ',', 1)+1);
list[2] = atoi(indexn(_optarg, ',', 2)+1);
/* N must be positive */
if(list[2] <= 0)
{
fprintf(stderr, "error parsing parameter -%c\n\n", param);
usage(stderr);
exit(1);
}
/* ensure that start < stop */
if(list[0] > list[1])
swap(&list[0], &list[1]);
break;
default:
fprintf(stderr, "Can't parse range %s.\n\n", _optarg);
usage(stderr);
exit(1);
}
}
/** Receiving a SMS, third step, content in gsm_buf
Message can be
Bdd where dd is a block index on two digits. WARNING: dd > 0
Sdd value where dd>0 is a var index on two digits and value is a float
*/
static void gsm_receive_content(void)
{
// ?????? sprintf(data_to_send, "%d %s %s %s %s", index_msg, flag, expediteur, dateheure, data_recue);
// ?????? Send(data_to_send);
// Checking the number of the sender
if (
//#if ! (defined GCS_NUMBER_1 || defined GCS_NUMBER_2 || defined SAFETY_NUMBER_1 || defined SAFETY_NUMBER_2)
true
//#else
// false
//#endif
#ifdef GCS_NUMBER_1
|| strncmp((char*)GCS_NUMBER_1, origin, strlen(GCS_NUMBER_1)) == 0
#endif
#ifdef GCS_NUMBER_2
|| strncmp((char*)GCS_NUMBER_2, origin, strlen(GCS_NUMBER_2)) == 0
#endif
#ifdef SAFETY_NUMBER_1
|| strncmp((char*)SAFETY_NUMBER_1, origin, strlen(SAFETY_NUMBER_1)) == 0
#endif
#ifdef SAFETY_NUMBER_2
|| strncmp((char*)SAFETY_NUMBER_2, origin, strlen(SAFETY_NUMBER_2)) == 0
#endif
) {
// Decoding the message ...
// Search for the instruction
switch (gsm_buf[0]) {
case 'B' :
{
uint8_t block_index = atoi(gsm_buf+1);
if (block_index > 0) /* Warning: no way to go to the first block */
nav_goto_block(block_index);
break;
}
case 'S' :
{
uint8_t var_index = atoi(gsm_buf+1);
if (var_index > 0) {
float value = atof(indexn(gsm_buf, ' ',MAXLEN_SMS_CONTENT)+1);
DlSetting(var_index, value);
}
}
default:
// Report an error ???
break;
}
}
}
// A line of length gsm_buf_len is available in the gsm_buf buffer
static void gsm_got_line(void)
{
if (gsm_status == STATUS_WAITING_DATA) { // Currently receiving a SMS
gsm_receive_content();
Suppr_SMS(index_msg);
gsm_status = STATUS_DELETE_SMS;
} else if (gsm_status == STATUS_IDLE
&& strncmp(CMTI, gsm_buf, strlen(CMTI)) == 0) {
/* A SMS is available */
/* Extracting the index of the message */
char *first_comma = indexn(gsm_buf, ',', MAXLEN_CMTI_ANSWER);
if (first_comma) {
index_msg = atoi(first_comma + 1);
request_for_msg();
gsm_status = STATUS_REQUESTING_MESSAGE;
}
} else if (waiting_for_reply) { // Other cases
// Do we get what we were expecting
bool gsm_answer = strncmp(expected_ack, gsm_buf, strlen(expected_ack)) == 0;
if (gsm_answer) {
waiting_for_reply = false;
switch (gsm_status) {
case STATUS_CSQ :
gsm_send_report_continue();
gsm_status = STATUS_WAITING_PROMPT;
break;
case STATUS_REQUESTING_MESSAGE:
parse_msg_header();
gsm_status = STATUS_WAITING_DATA;
break;
case STATUS_SEND_AT :
gsm_answer = false;
Send_CMGF();
gsm_status = STATUS_SEND_CMGF;
break;
case STATUS_SEND_CMGF :
gsm_answer = false;
Send_CNMI();
gsm_status = STATUS_SEND_CNMI;
break;
case STATUS_SEND_CNMI :
gsm_answer = false;
Send_CPMS();
gsm_status = STATUS_SEND_CPMS;
break;
case STATUS_SEND_CPMS :
gsm_answer = false;
gsm_status = STATUS_IDLE;
gsm_gsm_send_report_status = MODULES_START; /** Start reporting */
break;
case STATUS_DELETE_SMS :
gsm_status = STATUS_IDLE;
break;
default:
break;
}
} else { /** We did not get the expected answer */
/* Let's wait for the next line */
}
}
}
static void do_sham(const char *fn, const char *ndx,
const char *xpmP, const char *xpm, const char *xpm2,
const char *xpm3, const char *pdb,
const char *logf,
int n, int neig, real **eig,
gmx_bool bGE, int nenerT, real **enerT,
real Tref,
real pmax, real gmax,
real *emin, real *emax, int nlevels, real pmin,
int *idim, int *ibox,
gmx_bool bXmin, real *xmin, gmx_bool bXmax, real *xmax)
{
FILE *fp;
real *min_eig, *max_eig;
real *axis_x, *axis_y, *axis_z, *axis = NULL;
double *P;
real **PP, *W, *E, **WW, **EE, *S, **SS, *M, *bE;
rvec xxx;
char *buf;
double *bfac, efac, bref, Pmax, Wmin, Wmax, Winf, Emin, Emax, Einf, Smin, Smax, Sinf, Mmin, Mmax;
real *delta;
int i, j, k, imin, len, index, d, *nbin, *bindex, bi;
int *nxyz, maxbox;
t_blocka *b;
gmx_bool bOutside;
unsigned int flags;
t_rgb rlo = { 0, 0, 0 };
t_rgb rhi = { 1, 1, 1 };
/* Determine extremes for the eigenvectors */
snew(min_eig, neig);
snew(max_eig, neig);
snew(nxyz, neig);
snew(bfac, neig);
snew(delta, neig);
for (i = 0; (i < neig); i++)
{
/* Check for input constraints */
min_eig[i] = max_eig[i] = eig[i][0];
for (j = 0; (j < n); j++)
{
min_eig[i] = min(min_eig[i], eig[i][j]);
max_eig[i] = max(max_eig[i], eig[i][j]);
delta[i] = (max_eig[i]-min_eig[i])/(2.0*ibox[i]);
}
/* Add some extra space, half a bin on each side, unless the
* user has set the limits.
*/
if (bXmax)
{
if (max_eig[i] > xmax[i])
{
gmx_warning("Your xmax[%d] value %f is smaller than the largest data point %f", i, xmax[i], max_eig[i]);
}
max_eig[i] = xmax[i];
}
else
{
max_eig[i] += delta[i];
}
if (bXmin)
{
if (min_eig[i] < xmin[i])
{
gmx_warning("Your xmin[%d] value %f is larger than the smallest data point %f", i, xmin[i], min_eig[i]);
}
min_eig[i] = xmin[i];
}
else
{
min_eig[i] -= delta[i];
}
bfac[i] = ibox[i]/(max_eig[i]-min_eig[i]);
}
/* Do the binning */
bref = 1/(BOLTZ*Tref);
snew(bE, n);
if (bGE || nenerT == 2)
{
Emin = 1e8;
for (j = 0; (j < n); j++)
{
if (bGE)
{
bE[j] = bref*enerT[0][j];
}
else
{
bE[j] = (bref - 1/(BOLTZ*enerT[1][j]))*enerT[0][j];
}
Emin = min(Emin, bE[j]);
}
}
else
{
Emin = 0;
}
len = 1;
for (i = 0; (i < neig); i++)
{
len = len*ibox[i];
}
printf("There are %d bins in the %d-dimensional histogram. Beta-Emin = %g\n",
len, neig, Emin);
snew(P, len);
snew(W, len);
snew(E, len);
snew(S, len);
snew(M, len);
snew(nbin, len);
snew(bindex, n);
/* Loop over projections */
for (j = 0; (j < n); j++)
{
/* Loop over dimensions */
bOutside = FALSE;
for (i = 0; (i < neig); i++)
{
nxyz[i] = bfac[i]*(eig[i][j]-min_eig[i]);
if (nxyz[i] < 0 || nxyz[i] >= ibox[i])
{
bOutside = TRUE;
}
}
if (!bOutside)
{
index = indexn(neig, ibox, nxyz);
range_check(index, 0, len);
/* Compute the exponential factor */
if (enerT)
{
efac = exp(-bE[j]+Emin);
}
else
{
efac = 1;
}
/* Apply the bin volume correction for a multi-dimensional distance */
for (i = 0; i < neig; i++)
{
if (idim[i] == 2)
{
efac /= eig[i][j];
}
else if (idim[i] == 3)
{
efac /= sqr(eig[i][j]);
}
else if (idim[i] == -1)
{
efac /= sin(DEG2RAD*eig[i][j]);
}
}
/* Update the probability */
P[index] += efac;
/* Update the energy */
if (enerT)
{
E[index] += enerT[0][j];
}
/* Statistics: which "structure" in which bin */
nbin[index]++;
bindex[j] = index;
}
}
/* Normalize probability */
normalize_p_e(len, P, nbin, E, pmin);
Pmax = 0;
/* Compute boundaries for the Free energy */
Wmin = 1e8;
imin = -1;
Wmax = -1e8;
/* Recompute Emin: it may have changed due to averaging */
Emin = 1e8;
Emax = -1e8;
for (i = 0; (i < len); i++)
{
if (P[i] != 0)
{
Pmax = max(P[i], Pmax);
W[i] = -BOLTZ*Tref*log(P[i]);
if (W[i] < Wmin)
{
Wmin = W[i];
imin = i;
}
Emin = min(E[i], Emin);
Emax = max(E[i], Emax);
Wmax = max(W[i], Wmax);
}
}
if (pmax > 0)
{
Pmax = pmax;
}
if (gmax > 0)
{
Wmax = gmax;
}
else
{
Wmax -= Wmin;
}
Winf = Wmax+1;
Einf = Emax+1;
Smin = Emin-Wmax;
Smax = Emax-Smin;
Sinf = Smax+1;
/* Write out the free energy as a function of bin index */
fp = gmx_ffopen(fn, "w");
for (i = 0; (i < len); i++)
{
if (P[i] != 0)
{
W[i] -= Wmin;
S[i] = E[i]-W[i]-Smin;
fprintf(fp, "%5d %10.5e %10.5e %10.5e\n", i, W[i], E[i], S[i]);
}
else
{
W[i] = Winf;
E[i] = Einf;
S[i] = Sinf;
}
}
gmx_ffclose(fp);
/* Organize the structures in the bins */
snew(b, 1);
snew(b->index, len+1);
snew(b->a, n);
b->index[0] = 0;
for (i = 0; (i < len); i++)
{
b->index[i+1] = b->index[i]+nbin[i];
nbin[i] = 0;
}
for (i = 0; (i < n); i++)
{
bi = bindex[i];
b->a[b->index[bi]+nbin[bi]] = i;
nbin[bi]++;
}
/* Consistency check */
/* This no longer applies when we allow the plot to be smaller
than the sampled space.
for(i=0; (i<len); i++) {
if (nbin[i] != (b->index[i+1] - b->index[i]))
gmx_fatal(FARGS,"nbin[%d] = %d, should be %d",i,nbin[i],
b->index[i+1] - b->index[i]);
}
*/
/* Write the index file */
fp = gmx_ffopen(ndx, "w");
for (i = 0; (i < len); i++)
{
if (nbin[i] > 0)
{
fprintf(fp, "[ %d ]\n", i);
for (j = b->index[i]; (j < b->index[i+1]); j++)
{
fprintf(fp, "%d\n", b->a[j]+1);
}
}
}
gmx_ffclose(fp);
snew(axis_x, ibox[0]+1);
snew(axis_y, ibox[1]+1);
snew(axis_z, ibox[2]+1);
maxbox = max(ibox[0], max(ibox[1], ibox[2]));
snew(PP, maxbox*maxbox);
snew(WW, maxbox*maxbox);
snew(EE, maxbox*maxbox);
snew(SS, maxbox*maxbox);
for (i = 0; (i < min(neig, 3)); i++)
{
switch (i)
{
case 0: axis = axis_x; break;
case 1: axis = axis_y; break;
case 2: axis = axis_z; break;
default: break;
}
for (j = 0; j <= ibox[i]; j++)
{
axis[j] = min_eig[i] + j/bfac[i];
}
}
pick_minima(logf, ibox, neig, len, W);
if (gmax <= 0)
{
gmax = Winf;
}
flags = MAT_SPATIAL_X | MAT_SPATIAL_Y;
if (neig == 2)
{
/* Dump to XPM file */
snew(PP, ibox[0]);
for (i = 0; (i < ibox[0]); i++)
{
snew(PP[i], ibox[1]);
for (j = 0; j < ibox[1]; j++)
{
PP[i][j] = P[i*ibox[1]+j];
}
WW[i] = &(W[i*ibox[1]]);
EE[i] = &(E[i*ibox[1]]);
SS[i] = &(S[i*ibox[1]]);
}
fp = gmx_ffopen(xpmP, "w");
write_xpm(fp, flags, "Probability Distribution", "", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, PP, 0, Pmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm, "w");
write_xpm(fp, flags, "Gibbs Energy Landscape", "G (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm2, "w");
write_xpm(fp, flags, "Enthalpy Landscape", "H (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, EE,
emin ? *emin : Emin, emax ? *emax : Einf, rlo, rhi, &nlevels);
gmx_ffclose(fp);
fp = gmx_ffopen(xpm3, "w");
write_xpm(fp, flags, "Entropy Landscape", "TDS (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, SS, 0, Sinf, rlo, rhi, &nlevels);
gmx_ffclose(fp);
}
else if (neig == 3)
{
/* Dump to PDB file */
fp = gmx_ffopen(pdb, "w");
for (i = 0; (i < ibox[0]); i++)
{
xxx[XX] = 3*(i+0.5-ibox[0]/2);
for (j = 0; (j < ibox[1]); j++)
{
xxx[YY] = 3*(j+0.5-ibox[1]/2);
for (k = 0; (k < ibox[2]); k++)
{
xxx[ZZ] = 3*(k+0.5-ibox[2]/2);
index = index3(ibox, i, j, k);
if (P[index] > 0)
{
fprintf(fp, "%-6s%5u %-4.4s%3.3s %4d %8.3f%8.3f%8.3f%6.2f%6.2f\n",
"ATOM", (index+1) %10000, "H", "H", (index+1)%10000,
xxx[XX], xxx[YY], xxx[ZZ], 1.0, W[index]);
}
}
}
}
gmx_ffclose(fp);
write_xplor("out.xplor", W, ibox, min_eig, max_eig);
nxyz[XX] = imin/(ibox[1]*ibox[2]);
nxyz[YY] = (imin-nxyz[XX]*ibox[1]*ibox[2])/ibox[2];
nxyz[ZZ] = imin % ibox[2];
for (i = 0; (i < ibox[0]); i++)
{
snew(WW[i], maxbox);
for (j = 0; (j < ibox[1]); j++)
{
WW[i][j] = W[index3(ibox, i, j, nxyz[ZZ])];
}
}
snew(buf, strlen(xpm)+4);
sprintf(buf, "%s", xpm);
sprintf(&buf[strlen(xpm)-4], "12.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "Gibbs Energy Landscape", "W (kJ/mol)", "PC1", "PC2",
ibox[0], ibox[1], axis_x, axis_y, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
for (i = 0; (i < ibox[0]); i++)
{
for (j = 0; (j < ibox[2]); j++)
{
WW[i][j] = W[index3(ibox, i, nxyz[YY], j)];
}
}
sprintf(&buf[strlen(xpm)-4], "13.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "SHAM Energy Landscape", "kJ/mol", "PC1", "PC3",
ibox[0], ibox[2], axis_x, axis_z, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
for (i = 0; (i < ibox[1]); i++)
{
for (j = 0; (j < ibox[2]); j++)
{
WW[i][j] = W[index3(ibox, nxyz[XX], i, j)];
}
}
sprintf(&buf[strlen(xpm)-4], "23.xpm");
fp = gmx_ffopen(buf, "w");
write_xpm(fp, flags, "SHAM Energy Landscape", "kJ/mol", "PC2", "PC3",
ibox[1], ibox[2], axis_y, axis_z, WW, 0, gmax, rlo, rhi, &nlevels);
gmx_ffclose(fp);
sfree(buf);
}
}
static void pick_minima(const char *logfile, int *ibox, int ndim, int len, real W[])
{
FILE *fp;
int i, j, k, nmin;
t_minimum *mm, this_min;
int *this_point;
int loopmax, loopcounter;
snew(mm, len);
nmin = 0;
fp = gmx_ffopen(logfile, "w");
/* Loop over each element in the array of dimenion ndim seeking
* minima with respect to every dimension. Specialized loops for
* speed with ndim == 2 and ndim == 3. */
switch (ndim)
{
case 0:
/* This is probably impossible to reach anyway. */
break;
case 2:
for (i = 0; (i < ibox[0]); i++)
{
for (j = 0; (j < ibox[1]); j++)
{
/* Get the index of this point in the flat array */
this_min.index = index2(ibox, i, j);
this_min.ener = W[this_min.index];
if (is_local_minimum_from_below(&this_min, i, 0, index2(ibox, i-1, j ), W) &&
is_local_minimum_from_above(&this_min, i, ibox[0]-1, index2(ibox, i+1, j ), W) &&
is_local_minimum_from_below(&this_min, j, 0, index2(ibox, i, j-1), W) &&
is_local_minimum_from_above(&this_min, j, ibox[1]-1, index2(ibox, i, j+1), W))
{
add_minimum(fp, nmin, &this_min, mm);
nmin++;
}
}
}
break;
case 3:
for (i = 0; (i < ibox[0]); i++)
{
for (j = 0; (j < ibox[1]); j++)
{
for (k = 0; (k < ibox[2]); k++)
{
/* Get the index of this point in the flat array */
this_min.index = index3(ibox, i, j, k);
this_min.ener = W[this_min.index];
if (is_local_minimum_from_below(&this_min, i, 0, index3(ibox, i-1, j, k ), W) &&
is_local_minimum_from_above(&this_min, i, ibox[0]-1, index3(ibox, i+1, j, k ), W) &&
is_local_minimum_from_below(&this_min, j, 0, index3(ibox, i, j-1, k ), W) &&
is_local_minimum_from_above(&this_min, j, ibox[1]-1, index3(ibox, i, j+1, k ), W) &&
is_local_minimum_from_below(&this_min, k, 0, index3(ibox, i, j, k-1), W) &&
is_local_minimum_from_above(&this_min, k, ibox[2]-1, index3(ibox, i, j, k+1), W))
{
add_minimum(fp, nmin, &this_min, mm);
nmin++;
}
}
}
}
break;
default:
/* Note this treats ndim == 1 and ndim > 3 */
/* Set up an ndim-dimensional vector to loop over the points
* on the grid. (0,0,0, ... 0) is an acceptable place to
* start. */
snew(this_point, ndim);
/* Determine the number of points of the ndim-dimensional
* grid. */
loopmax = ibox[0];
for (i = 1; i < ndim; i++)
{
loopmax *= ibox[i];
}
loopcounter = 0;
while (loopmax > loopcounter)
{
gmx_bool bMin = TRUE;
/* Get the index of this_point in the flat array */
this_min.index = indexn(ndim, ibox, this_point);
this_min.ener = W[this_min.index];
/* Is this_point a minimum from above and below in each
* dimension? */
for (i = 0; bMin && (i < ndim); i++)
{
/* Save the index of this_point within the curent
* dimension so we can change that index in the
* this_point array for use with indexn(). */
int index = this_point[i];
this_point[i]--;
bMin = bMin &&
is_local_minimum_from_below(&this_min, index, 0, indexn(ndim, ibox, this_point), W);
this_point[i] += 2;
bMin = bMin &&
is_local_minimum_from_above(&this_min, index, ibox[i]-1, indexn(ndim, ibox, this_point), W);
this_point[i]--;
}
if (bMin)
{
add_minimum(fp, nmin, &this_min, mm);
nmin++;
}
/* update global loop counter */
loopcounter++;
/* Avoid underflow of this_point[i] */
if (loopmax > loopcounter)
{
/* update this_point non-recursively */
i = ndim-1;
this_point[i]++;
while (ibox[i] == this_point[i])
{
this_point[i] = 0;
i--;
/* this_point[i] cannot underflow because
* loopmax > loopcounter. */
this_point[i]++;
}
}
}
sfree(this_point);
break;
}
qsort(mm, nmin, sizeof(mm[0]), comp_minima);
fprintf(fp, "Minima sorted after energy\n");
for (i = 0; (i < nmin); i++)
{
print_minimum(fp, i, &mm[i]);
}
gmx_ffclose(fp);
sfree(mm);
}
