void UpdateGroupsCog::addCogs(gmx::ArrayRef<const int> globalAtomIndices,
gmx::ArrayRef<const gmx::RVec> coordinates)
{
const int localAtomBegin = cogIndices_.size();
const size_t cogBegin = cogs_.size();
GMX_RELEASE_ASSERT(globalAtomIndices.size() >= localAtomBegin,
"addCogs should only be called to add COGs to the list that is already present (which could be empty)");
cogIndices_.reserve(globalAtomIndices.size());
int moleculeBlock = 0;
for (int localAtom = localAtomBegin; localAtom < globalAtomIndices.size(); localAtom++)
{
const int globalAtom = globalAtomIndices[localAtom];
int moleculeIndex;
int atomIndexInMolecule;
mtopGetMolblockIndex(&mtop_, globalAtom,
&moleculeBlock, &moleculeIndex, &atomIndexInMolecule);
const auto &indicesForBlock = indicesPerMoleculeblock_[moleculeBlock];
int globalUpdateGroupIndex =
indicesForBlock.groupStart_ +
moleculeIndex*indicesForBlock.numGroupsPerMolecule_ +
indicesForBlock.groupIndex_[atomIndexInMolecule];
if (const int *cogIndexPtr = globalToLocalMap_.find(globalUpdateGroupIndex))
{
GMX_ASSERT(static_cast<size_t>(*cogIndexPtr) >= cogBegin,
"Added atoms should not be part of previously present groups");
cogIndices_.push_back(*cogIndexPtr);
cogs_[*cogIndexPtr] += coordinates[localAtom];
numAtomsPerCog_[*cogIndexPtr]++;
}
else
{
const int cogIndex = cogs_.size();
globalToLocalMap_.insert(globalUpdateGroupIndex, cogIndex);
cogIndices_.push_back(cogIndex);
cogs_.push_back(coordinates[localAtom]);
numAtomsPerCog_.push_back(1);
}
}
/* Divide sum of coordinates for each COG by the number of atoms */
for (size_t i = cogBegin; i < cogs_.size(); i++)
{
const int numAtoms = numAtomsPerCog_[i];
if (numAtoms > 1)
{
cogs_[i] /= numAtoms;
}
}
}
void
ddSendrecv(const gmx_domdec_t *dd,
int ddDimensionIndex,
int direction,
gmx::ArrayRef<T> sendBuffer,
gmx::ArrayRef<T> receiveBuffer)
{
ddSendrecv(dd, ddDimensionIndex, direction,
sendBuffer.data(), sendBuffer.size(),
receiveBuffer.data(), receiveBuffer.size());
}
static void do_demux(gmx::ArrayRef<const std::string> inFiles,
gmx::ArrayRef<const std::string> outFiles, int nval,
real **value, real *time, real dt_remd, int isize,
int index[], real dt, const gmx_output_env_t *oenv)
{
int k, natoms;
t_trxstatus **fp_in, **fp_out;
gmx_bool bCont, *bSet;
real t, first_time = 0;
t_trxframe *trx;
snew(fp_in, inFiles.size());
snew(trx, inFiles.size());
snew(bSet, inFiles.size());
natoms = -1;
t = -1;
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
read_first_frame(oenv, &(fp_in[i]), inFiles[i].c_str(), &(trx[i]),
TRX_NEED_X);
if (natoms == -1)
{
natoms = trx[i].natoms;
first_time = trx[i].time;
}
else if (natoms != trx[i].natoms)
{
gmx_fatal(FARGS, "Trajectory file %s has %d atoms while previous trajs had %d atoms", inFiles[i].c_str(), trx[i].natoms, natoms);
}
if (t == -1)
{
t = trx[i].time;
}
else if (t != trx[i].time)
{
gmx_fatal(FARGS, "Trajectory file %s has time %f while previous trajs had time %f", inFiles[i].c_str(), trx[i].time, t);
}
}
snew(fp_out, inFiles.size());
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
fp_out[i] = open_trx(outFiles[i].c_str(), "w");
}
k = 0;
if (std::round(time[k] - t) != 0)
{
gmx_fatal(FARGS, "First time in demuxing table does not match trajectories");
}
do
{
while ((k+1 < nval) && ((trx[0].time - time[k+1]) > dt_remd*0.1))
{
k++;
}
if (debug)
{
fprintf(debug, "trx[0].time = %g, time[k] = %g\n", trx[0].time, time[k]);
}
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
bSet[i] = FALSE;
}
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
int j = gmx::roundToInt(value[i][k]);
range_check(j, 0, inFiles.size());
if (bSet[j])
{
gmx_fatal(FARGS, "Demuxing the same replica %d twice at time %f",
j, trx[0].time);
}
bSet[j] = TRUE;
if (dt == 0 || bRmod(trx[i].time, first_time, dt))
{
if (index)
{
write_trxframe_indexed(fp_out[j], &trx[i], isize, index, nullptr);
}
else
{
write_trxframe(fp_out[j], &trx[i], nullptr);
}
}
}
bCont = (k < nval);
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
bCont = bCont && read_next_frame(oenv, fp_in[i], &trx[i]);
}
}
while (bCont);
for (gmx::index i = 0; i < inFiles.ssize(); i++)
{
close_trx(fp_in[i]);
close_trx(fp_out[i]);
}
}
static void edit_files(gmx::ArrayRef<std::string> files,
real *readtime, real *timestep,
real *settime, int *cont_type, gmx_bool bSetTime,
gmx_bool bSort, const gmx_output_env_t *oenv)
{
gmx_bool ok;
char inputstring[STRLEN], *chptr;
auto timeUnit = output_env_get_time_unit(oenv);
if (bSetTime)
{
fprintf(stderr, "\n\nEnter the new start time (%s) for each file.\n"
"There are two special options, both disable sorting:\n\n"
"c (continue) - The start time is taken from the end\n"
"of the previous file. Use it when your continuation run\n"
"restarts with t=0.\n\n"
"l (last) - The time in this file will be changed the\n"
"same amount as in the previous. Use it when the time in the\n"
"new run continues from the end of the previous one,\n"
"since this takes possible overlap into account.\n\n",
timeUnit.c_str());
fprintf(
stderr,
" File Current start (%s) New start (%s)\n"
"---------------------------------------------------------\n",
timeUnit.c_str(), timeUnit.c_str());
for (gmx::index i = 0; i < files.ssize(); i++)
{
fprintf(stderr, "%25s %10.3f %s ", files[i].c_str(),
output_env_conv_time(oenv, readtime[i]), timeUnit.c_str());
ok = FALSE;
do
{
if (nullptr == fgets(inputstring, STRLEN - 1, stdin))
{
gmx_fatal(FARGS, "Error reading user input" );
}
inputstring[std::strlen(inputstring)-1] = 0;
if (inputstring[0] == 'c' || inputstring[0] == 'C')
{
cont_type[i] = TIME_CONTINUE;
bSort = FALSE;
ok = TRUE;
settime[i] = FLT_MAX;
}
else if (inputstring[0] == 'l' ||
inputstring[0] == 'L')
{
cont_type[i] = TIME_LAST;
bSort = FALSE;
ok = TRUE;
settime[i] = FLT_MAX;
}
else
{
settime[i] = strtod(inputstring, &chptr)*
output_env_get_time_invfactor(oenv);
if (chptr == inputstring)
{
fprintf(stderr, "'%s' not recognized as a floating point number, 'c' or 'l'. "
"Try again: ", inputstring);
}
else
{
cont_type[i] = TIME_EXPLICIT;
ok = TRUE;
}
}
}
while (!ok);
}
if (cont_type[0] != TIME_EXPLICIT)
{
cont_type[0] = TIME_EXPLICIT;
settime[0] = 0;
}
}
else
{
for (gmx::index i = 0; i < files.ssize(); i++)
{
settime[i] = readtime[i];
}
}
if (!bSort)
{
fprintf(stderr, "Sorting disabled.\n");
}
else
{
sort_files(files, settime);
}
/* Write out the new order and start times */
fprintf(stderr, "\nSummary of files and start times used:\n\n"
" File Start time Time step\n"
"---------------------------------------------------------\n");
for (gmx::index i = 0; i < files.ssize(); i++)
{
switch (cont_type[i])
{
case TIME_EXPLICIT:
fprintf(stderr, "%25s %10.3f %s %10.3f %s",
files[i].c_str(),
output_env_conv_time(oenv, settime[i]), timeUnit.c_str(),
output_env_conv_time(oenv, timestep[i]), timeUnit.c_str());
if (i > 0 &&
cont_type[i-1] == TIME_EXPLICIT && settime[i] == settime[i-1])
{
fprintf(stderr, " WARNING: same Start time as previous");
}
fprintf(stderr, "\n");
break;
case TIME_CONTINUE:
fprintf(stderr, "%25s Continue from last file\n", files[i].c_str());
break;
case TIME_LAST:
fprintf(stderr, "%25s Change by same amount as last file\n",
files[i].c_str());
break;
}
}
fprintf(stderr, "\n");
settime[files.size()] = FLT_MAX;
cont_type[files.size()] = TIME_EXPLICIT;
readtime[files.size()] = FLT_MAX;
}