int TrajinList::AddTrajin(std::string const& fname, Topology* topIn, ArgList const& argIn)
{
if (topIn == 0) {
mprinterr("Error: No topology for input trajectory '%s'\n", fname.c_str());
return 1;
}
// CRDIDXARG
finalCrdIndicesArg_.clear();
ArgList trajin_args = argIn;
bool isRemdtraj = trajin_args.hasKey("remdtraj");
int err = 0;
File::NameArray fnames = File::ExpandToFilenames( fname );
if (fnames.empty()) return 1;
Trajin* traj = 0;
for (File::NameArray::const_iterator fn = fnames.begin(); fn != fnames.end(); ++fn) {
ArgList args = trajin_args;
if (isRemdtraj)
traj = new Trajin_Multi();
else
traj = new Trajin_Single();
if (traj == 0) {
mprinterr("Error: Memory allocation for input trajectory failed.\n");
return 1;
}
traj->SetDebug(debug_);
if ( traj->SetupTrajRead(*fn, args, topIn) ) {
mprinterr("Error: Could not set up input trajectory '%s'.\n", fn->full());
delete traj;
err++;
continue;
}
// Add to trajin list and update # of frames.
trajin_.push_back( traj );
UpdateMaxFrames( traj->Traj() );
}
if (err > 0) return 1;
// FIXME: For backwards compat. overwrite Topology box info with traj box info.
topIn->SetBoxFromTraj( trajin_.back()->TrajCoordInfo().TrajBox() );
return 0;
}
Exec::RetType Exec_ReadData::Execute(CpptrajState& State, ArgList& argIn) {
DataFile dataIn;
dataIn.SetDebug( State.DFL().Debug() );
std::string filenameIn = argIn.GetStringNext();
File::NameArray fnames = File::ExpandToFilenames( filenameIn );
if (fnames.empty()) {
mprinterr("Error: '%s' matches no files.\n", filenameIn.c_str());
return CpptrajState::ERR;
}
int err = 0;
int idx = -1;
bool useIndex = argIn.hasKey("separate");
for (File::NameArray::const_iterator fn = fnames.begin(); fn != fnames.end(); ++fn) {
if (useIndex) idx++;
if (dataIn.ReadDataIn( *fn, argIn, State.DSL(), idx, fnames.size() )!=0) {
mprinterr("Error: Could not read data file '%s'.\n", fn->full());
err++;
}
}
if (err > 0) return CpptrajState::ERR;
return CpptrajState::OK;
}
// TrajinList::AddEnsembleIn()
int TrajinList::AddEnsembleIn(std::string const& fname, Topology* topIn, ArgList const& argIn)
{
if (topIn == 0) {
mprinterr("Error: No topology for input ensemble '%s'\n", fname.c_str());
return 1;
}
int err = 0;
File::NameArray fnames = File::ExpandToFilenames( fname );
if (fnames.empty()) return 1;
TrajectoryFile::TrajFormatType trajinFmt;
TrajectoryIO* tio = 0;
for (File::NameArray::const_iterator fn = fnames.begin(); fn != fnames.end(); ++fn) {
ArgList args = argIn;
// Determine whether this file is multiple file or single file ensemble.
tio = TrajectoryFile::DetectFormat( *fn, trajinFmt );
if (tio == 0) {
mprinterr("Error: Could not determine trajectory %s format\n", fn->full());
err++;
continue;
}
EnsembleIn* ensemble = 0;
# ifdef ENABLE_SINGLE_ENSEMBLE
if (tio->CanProcessEnsemble())
ensemble = new EnsembleIn_Single();
else
# endif
ensemble = new EnsembleIn_Multi();
if (ensemble == 0) {
mprinterr("Error: Memory allocation for input ensemble failed.\n");
delete tio;
return 1;
}
ensemble->SetDebug( debug_ );
// CRDIDXARG: Append coordinate indices arg if there is one
args.AddArg( finalCrdIndicesArg_ );
if ( ensemble->SetupEnsembleRead(*fn, args, topIn) ) {
mprinterr("Error: Could not set up input ensemble '%s'.\n", fname.c_str());
delete ensemble;
delete tio;
err++;
continue;
}
// Currently all input ensembles must be same size.
if (ensembleSize_ == -1)
ensembleSize_ = ensemble->EnsembleCoordInfo().EnsembleSize();
else if (ensembleSize_ != ensemble->EnsembleCoordInfo().EnsembleSize()) {
mprinterr("Error: Ensemble size (%i) does not match first ensemble size (%i).\n",
ensemble->EnsembleCoordInfo().EnsembleSize(), ensembleSize_);
return 1;
}
// CRDIDXARG: If trajectory is REMD ensemble and sorting by CRDIDX, need to
// save final CRDIDX for next ensemble command.
// TODO: This is very clunky - remlog dataset should contain all exchanges
// so trajin doesnt have to worry about it.
# ifdef ENABLE_SINGLE_ENSEMBLE
if ( !tio->CanProcessEnsemble() ) {
# endif
EnsembleIn_Multi const& mTraj = static_cast<EnsembleIn_Multi const&>( *ensemble );
if ( mTraj.TargetMode() == ReplicaInfo::CRDIDX ) {
finalCrdIndicesArg_ = mTraj.FinalCrdIndices();
if (finalCrdIndicesArg_.empty()) {
mprinterr("Error: Could not obtain final remlog indices.\n");
delete ensemble;
delete tio;
err++;
continue;
}
//mprintf("DEBUG: Final crd indices arg: %s\n", finalCrdIndicesArg_.c_str());
}
# ifdef ENABLE_SINGLE_ENSEMBLE
} else
mprintf("Warning: Single ensemble cannot process crdidx.\n");
# endif
// Add to ensemble list and update # of frames.
ensemble_.push_back( ensemble );
UpdateMaxFrames( ensemble->Traj() );
delete tio;
}
if (err > 0) return 1;
// FIXME: For backwards compat. overwrite Topology box info with traj box info.
topIn->SetBoxFromTraj( ensemble_.back()->EnsembleCoordInfo().TrajBox() );
return 0;
}
/** Loop over all filenames in replica_filenames, set up TrajectoryIO. */
int TrajIOarray::SetupIOarray(ArgList& argIn, TrajFrameCounter& counter,
CoordinateInfo& cInfo, Topology* trajParm)
{
// Sanity check
if (!IOarray_.empty()) {
mprinterr("Internal Error: SetupIOarray() has been called twice.\n");
return 1;
}
// Save arguments that have not been processed so they can be passed
// to each replica in turn. Only the lowest replica will use argIn.
ArgList argCopy( argIn );
bool lowestRep = true;
int rep0Frames = TrajectoryIO::TRAJIN_UNK; // Total frames in replica 0
int totalFrames = TrajectoryIO::TRAJIN_UNK; // Total # frames to be read from ensemble
TrajectoryFile::TrajFormatType lastRepFmt = TrajectoryFile::UNKNOWN_TRAJ;
// Right now enforce that all replicas have the same metadata as lowest
// replica, e.g. if replica 0 has temperature, replica 1 does too etc.
for (File::NameArray::const_iterator repfile = replica_filenames_.begin();
repfile != replica_filenames_.end(); ++repfile)
{
// Detect format
TrajectoryFile::TrajFormatType repformat = TrajectoryFile::UNKNOWN_TRAJ;
TrajectoryIO* replica0 = TrajectoryFile::DetectFormat( *repfile, repformat );
if ( replica0 == 0 ) {
mprinterr("Error: Could not set up replica file %s\n", repfile->full());
return 1;
}
if (repformat != lastRepFmt)
mprintf("\tReading '%s' as %s\n", repfile->full(), TrajectoryFile::FormatString(repformat));
lastRepFmt = repformat;
replica0->SetDebug( debug_ );
// Pushing replica0 here allows the destructor to handle it on errors
IOarray_.push_back( replica0 );
// Process format-specific read args. Do not exit on error in case
// replicas have different formats supporting different args.
if (lowestRep) {
replica0->processReadArgs( argIn );
} else {
ArgList argtmp( argCopy );
replica0->processReadArgs( argtmp );
}
// Set up replica for reading and get the number of frames.
int nframes = replica0->setupTrajin( *repfile, trajParm );
if (nframes == TrajectoryIO::TRAJIN_ERR) {
mprinterr("Error: Could not set up %s for reading.\n", repfile->full());
return 1;
}
// TODO: Do not allow unknown number of frames?
if (lowestRep) {
cInfo = replica0->CoordInfo();
rep0Frames = nframes;
totalFrames = nframes;
if (cInfo.ReplicaDimensions().Ndims() > 0) {
mprintf("\tReplica dimensions:\n");
for (int rd = 0; rd < cInfo.ReplicaDimensions().Ndims(); rd++)
mprintf("\t\t%i: %s\n", rd+1, cInfo.ReplicaDimensions().Description(rd));
}
} else {
// Check total frames in this replica against lowest rep.
if (nframes != rep0Frames)
mprintf("Warning: Replica %s frames (%i) does not match # frames in first replica (%i).\n",
repfile->base(), nframes, rep0Frames);
//if (repframes < 0) {
// mprinterr("Error: RemdTraj: Unknown # of frames in replica.\n");
// return 1;
//}
if (nframes < totalFrames) {
totalFrames = nframes;
mprintf("Warning: Setting total # of frames to read from replica ensemble to %i\n",
totalFrames);
}
// Check box info against lowest rep.
if ( replica0->CoordInfo().HasBox() != cInfo.HasBox() ) {
mprinterr("Error: Replica %s box info does not match first replica.\n",
repfile->full());
return 1;
}
// TODO: Check specific box type
// Check velocity info against lowest rep.
if ( replica0->CoordInfo().HasVel() != cInfo.HasVel() ) {
mprinterr("Error: Replica %s velocity info does not match first replica.\n",
repfile->full());
return 1;
}
// Check # dimensions and types against lowest rep
if ( replica0->CoordInfo().ReplicaDimensions() != cInfo.ReplicaDimensions() ) {
mprinterr("Error: Replica %s dimension info does not match first replica.\n",
repfile->full());
ReplicaDimArray const& thisRepDims = replica0->CoordInfo().ReplicaDimensions();
for (int rd = 0; rd < thisRepDims.Ndims(); rd++)
mprinterr("\t\t%i: %s\n", rd+1, thisRepDims.Description(rd));
return 1;
}
// If temperature/time info does not match set to false.
if (cInfo.HasTemp() != replica0->CoordInfo().HasTemp())
cInfo.SetTemperature( false );
if (cInfo.HasTime() != replica0->CoordInfo().HasTime())
cInfo.SetTime( false );
}
lowestRep = false;
}
// Check how many frames will actually be read
if (counter.CheckFrameArgs( totalFrames, argIn )) return 1;
// Check for errors.
if (IOarray_.empty()) {
mprinterr("Error: No replica trajectories set up.\n");
return 1;
}
if (IOarray_.size() != replica_filenames_.size()) { // SANITY CHECK
mprinterr("Error: Not all replica files were set up.\n");
return 1;
}
// Update ensemble size
cInfo.SetEnsembleSize( (int)IOarray_.size() );
if (debug_ > 0)
cInfo.PrintCoordInfo( replica_filenames_[0].full(), trajParm->c_str() );
return 0;
}
/** Set up each mask/integer loop. */
int ControlBlock_For::SetupBlock(CpptrajState& State, ArgList& argIn) {
mprintf(" Setting up 'for' loop.\n");
Vars_.clear();
Topology* currentTop = 0;
static const char* TypeStr[] = { "ATOMS ", "RESIDUES ", "MOLECULES ",
"MOL_FIRST_RES ", "MOL_LAST_RES " };
static const char* OpStr[] = {"+=", "-=", "<", ">"};
description_.assign("for (");
int MaxIterations = -1;
int iarg = 0;
while (iarg < argIn.Nargs())
{
// Advance to next unmarked argument.
while (iarg < argIn.Nargs() && argIn.Marked(iarg)) iarg++;
if (iarg == argIn.Nargs()) break;
// Determine 'for' type
ForType ftype = UNKNOWN;
bool isMaskFor = true;
int argToMark = iarg;
if ( argIn[iarg] == "atoms" ) ftype = ATOMS;
else if ( argIn[iarg] == "residues" ) ftype = RESIDUES;
else if ( argIn[iarg] == "molecules" ) ftype = MOLECULES;
else if ( argIn[iarg] == "molfirstres" ) ftype = MOLFIRSTRES;
else if ( argIn[iarg] == "mollastres" ) ftype = MOLLASTRES;
else if ( argIn[iarg].find(";") != std::string::npos ) {
isMaskFor = false;
ftype = INTEGER;
}
// If type is still unknown, check for list.
if (ftype == UNKNOWN) {
if (iarg+1 < argIn.Nargs() && argIn[iarg+1] == "in") {
ftype = LIST;
isMaskFor = false;
argToMark = iarg+1;
}
}
// Exit if type could not be determined.
if (ftype == UNKNOWN) {
mprinterr("Error: for loop type not specfied.\n");
return 1;
}
argIn.MarkArg(argToMark);
Vars_.push_back( LoopVar() );
LoopVar& MH = Vars_.back();
int Niterations = -1;
// Set up for specific type
if (description_ != "for (") description_.append(", ");
// -------------------------------------------
if (isMaskFor)
{
// {atoms|residues|molecules} <var> inmask <mask> [TOP KEYWORDS]
if (argIn[iarg+2] != "inmask") {
mprinterr("Error: Expected 'inmask', got %s\n", argIn[iarg+2].c_str());
return 1;
}
AtomMask currentMask;
if (currentMask.SetMaskString( argIn.GetStringKey("inmask") )) return 1;
MH.varType_ = ftype;
Topology* top = State.DSL().GetTopByIndex( argIn );
if (top != 0) currentTop = top;
if (currentTop == 0) return 1;
MH.varname_ = argIn.GetStringNext();
if (MH.varname_.empty()) {
mprinterr("Error: 'for inmask': missing variable name.\n");
return 1;
}
MH.varname_ = "$" + MH.varname_;
// Set up mask
if (currentTop->SetupIntegerMask( currentMask )) return 1;
currentMask.MaskInfo();
if (currentMask.None()) return 1;
// Set up indices
if (MH.varType_ == ATOMS)
MH.Idxs_ = currentMask.Selected();
else if (MH.varType_ == RESIDUES) {
int curRes = -1;
for (AtomMask::const_iterator at = currentMask.begin(); at != currentMask.end(); ++at) {
int res = (*currentTop)[*at].ResNum();
if (res != curRes) {
MH.Idxs_.push_back( res );
curRes = res;
}
}
} else if (MH.varType_ == MOLECULES ||
MH.varType_ == MOLFIRSTRES ||
MH.varType_ == MOLLASTRES)
{
int curMol = -1;
for (AtomMask::const_iterator at = currentMask.begin(); at != currentMask.end(); ++at) {
int mol = (*currentTop)[*at].MolNum();
if (mol != curMol) {
if (MH.varType_ == MOLECULES)
MH.Idxs_.push_back( mol );
else {
int res;
if (MH.varType_ == MOLFIRSTRES)
res = (*currentTop)[ currentTop->Mol( mol ).BeginAtom() ].ResNum();
else // MOLLASTRES
res = (*currentTop)[ currentTop->Mol( mol ).EndAtom()-1 ].ResNum();
MH.Idxs_.push_back( res );
}
curMol = mol;
}
}
}
Niterations = (int)MH.Idxs_.size();
description_.append(std::string(TypeStr[MH.varType_]) +
MH.varname_ + " inmask " + currentMask.MaskExpression());
// -------------------------------------------
} else if (ftype == INTEGER) {
// [<var>=<start>;[<var><OP><end>;]<var><OP>[<value>]]
MH.varType_ = ftype;
ArgList varArg( argIn[iarg], ";" );
if (varArg.Nargs() < 2 || varArg.Nargs() > 3) {
mprinterr("Error: Malformed 'for' loop variable.\n"
"Error: Expected '[<var>=<start>;[<var><OP><end>;]<var><OP>[<value>]]'\n"
"Error: Got '%s'\n", argIn[iarg].c_str());
return 1;
}
// First argument: <var>=<start>
ArgList startArg( varArg[0], "=" );
if (startArg.Nargs() != 2) {
mprinterr("Error: Malformed 'start' argument.\n"
"Error: Expected <var>=<start>, got '%s'\n", varArg[0].c_str());
return 1;
}
MH.varname_ = startArg[0];
if (!validInteger(startArg[1])) {
// TODO allow variables
mprinterr("Error: Start argument must be an integer.\n");
return 1;
} else
MH.start_ = convertToInteger(startArg[1]);
// Second argument: <var><OP><end>
size_t pos0 = MH.varname_.size();
size_t pos1 = pos0 + 1;
MH.endOp_ = NO_OP;
int iargIdx = 1;
if (varArg.Nargs() == 3) {
iargIdx = 2;
if ( varArg[1][pos0] == '<' )
MH.endOp_ = LESS_THAN;
else if (varArg[1][pos0] == '>')
MH.endOp_ = GREATER_THAN;
if (MH.endOp_ == NO_OP) {
mprinterr("Error: Unrecognized end op: '%s'\n",
varArg[1].substr(pos0, pos1-pos0).c_str());
return 1;
}
std::string endStr = varArg[1].substr(pos1);
if (!validInteger(endStr)) {
// TODO allow variables
mprinterr("Error: End argument must be an integer.\n");
return 1;
} else
MH.end_ = convertToInteger(endStr);
}
// Third argument: <var><OP>[<value>]
pos1 = pos0 + 2;
MH.incOp_ = NO_OP;
bool needValue = false;
if ( varArg[iargIdx][pos0] == '+' ) {
if (varArg[iargIdx][pos0+1] == '+') {
MH.incOp_ = INCREMENT;
MH.inc_ = 1;
} else if (varArg[iargIdx][pos0+1] == '=') {
MH.incOp_ = INCREMENT;
needValue = true;
}
} else if ( varArg[iargIdx][pos0] == '-' ) {
if (varArg[iargIdx][pos0+1] == '-' ) {
MH.incOp_ = DECREMENT;
MH.inc_ = 1;
} else if (varArg[iargIdx][pos0+1] == '=') {
MH.incOp_ = DECREMENT;
needValue = true;
}
}
if (MH.incOp_ == NO_OP) {
mprinterr("Error: Unrecognized increment op: '%s'\n",
varArg[iargIdx].substr(pos0, pos1-pos0).c_str());
return 1;
}
if (needValue) {
std::string incStr = varArg[iargIdx].substr(pos1);
if (!validInteger(incStr)) {
mprinterr("Error: increment value is not a valid integer.\n");
return 1;
}
MH.inc_ = convertToInteger(incStr);
if (MH.inc_ < 1) {
mprinterr("Error: Extra '-' detected in increment.\n");
return 1;
}
}
// Description
MH.varname_ = "$" + MH.varname_;
std::string sval = integerToString(MH.start_);
description_.append("(" + MH.varname_ + "=" + sval + "; ");
std::string eval;
if (iargIdx == 2) {
// End argument present
eval = integerToString(MH.end_);
description_.append(MH.varname_ + std::string(OpStr[MH.endOp_]) + eval + "; ");
// Check end > start for increment, start > end for decrement
int maxval, minval;
if (MH.incOp_ == INCREMENT) {
if (MH.start_ >= MH.end_) {
mprinterr("Error: start must be less than end for increment.\n");
return 1;
}
minval = MH.start_;
maxval = MH.end_;
} else {
if (MH.end_ >= MH.start_) {
mprinterr("Error: end must be less than start for decrement.\n");
return 1;
}
minval = MH.end_;
maxval = MH.start_;
}
// Figure out number of iterations
Niterations = (maxval - minval) / MH.inc_;
if (((maxval-minval) % MH.inc_) > 0) Niterations++;
}
description_.append( MH.varname_ + std::string(OpStr[MH.incOp_]) +
integerToString(MH.inc_) + ")" );
// If decrementing just negate value
if (MH.incOp_ == DECREMENT)
MH.inc_ = -MH.inc_;
// DEBUG
//mprintf("DEBUG: start=%i endOp=%i end=%i incOp=%i val=%i startArg=%s endArg=%s\n",
// MH.start_, (int)MH.endOp_, MH.end_, (int)MH.incOp_, MH.inc_,
// MH.startArg_.c_str(), MH.endArg_.c_str());
// -------------------------------------------
} else if (ftype == LIST) {
// <var> in <string0>[,<string1>...]
MH.varType_ = ftype;
// Variable name
MH.varname_ = argIn.GetStringNext();
if (MH.varname_.empty()) {
mprinterr("Error: 'for in': missing variable name.\n");
return 1;
}
MH.varname_ = "$" + MH.varname_;
// Comma-separated list of strings
std::string listArg = argIn.GetStringNext();
if (listArg.empty()) {
mprinterr("Error: 'for in': missing comma-separated list of strings.\n");
return 1;
}
ArgList list(listArg, ",");
if (list.Nargs() < 1) {
mprinterr("Error: Could not parse '%s' for 'for in'\n", listArg.c_str());
return 1;
}
for (int il = 0; il != list.Nargs(); il++) {
// Check if file name expansion should occur
if (list[il].find_first_of("*?") != std::string::npos) {
File::NameArray files = File::ExpandToFilenames( list[il] );
for (File::NameArray::const_iterator fn = files.begin(); fn != files.end(); ++fn)
MH.List_.push_back( fn->Full() );
} else
MH.List_.push_back( list[il] );
}
Niterations = (int)MH.List_.size();
// Description
description_.append( MH.varname_ + " in " + listArg );
}
// Check number of values
if (MaxIterations == -1)
MaxIterations = Niterations;
else if (Niterations != -1 && Niterations != MaxIterations) {
mprintf("Warning: # iterations %i != previous # iterations %i\n",
Niterations, MaxIterations);
MaxIterations = std::min(Niterations, MaxIterations);
}
}
mprintf("\tLoop will execute for %i iterations.\n", MaxIterations);
if (MaxIterations < 1) {
mprinterr("Error: Loop has less than 1 iteration.\n");
return 1;
}
description_.append(") do");
return 0;
}