/** Add output trajectory to list as single output trajectory. Associate it
* with the given Topology but no Topology-dependent setup will occur. This
* is because during the course of a Run the Topology may be modified, by
* e.g. a 'strip' command.
*/
int TrajoutList::AddTrajout(std::string const& filename, ArgList const& argIn, Topology* tParm)
{
if (tParm == 0) {
mprinterr("Error: No topology information.\n");
return 1;
}
if (filename.empty()) {
mprinterr("Internal Error: TrajoutList::AddTrajout() called with empty filename.\n");
return 1;
}
// Determine if this filename is in use in order to prevent overwrites
for (ListType::const_iterator to = trajout_.begin();
to != trajout_.end(); ++to)
{
if ( (*to)->Traj().Filename().Full() == filename ) {
mprinterr("Error: Output trajectory filename %s already in use.\n",filename.c_str());
return 1;
}
}
// Create Trajout_Single
Trajout_Single* to = new Trajout_Single();
to->SetDebug( debug_ );
// Initialize output trajectory
ArgList args = argIn;
if (to->InitTrajWrite(filename, args, TrajectoryFile::UNKNOWN_TRAJ)) {
mprinterr("Error: Could not set up output trajectory.\n");
delete to;
return 1;
}
trajout_.push_back( to );
trajoutTops_.push_back( tParm );
open_.push_back( false );
return 0;
}
/** Write file containing only cut atoms and energies as charges. */
int Action_Pairwise::WriteCutFrame(int frameNum, Topology const& Parm, AtomMask const& CutMask,
Darray const& CutCharges,
Frame const& frame, std::string const& outfilename)
{
if (CutMask.Nselected() != (int)CutCharges.size()) {
mprinterr("Error: WriteCutFrame: # of charges (%u) != # mask atoms (%i)\n",
CutCharges.size(), CutMask.Nselected());
return 1;
}
Frame CutFrame(frame, CutMask);
Topology* CutParm = Parm.modifyStateByMask( CutMask );
if (CutParm == 0) return 1;
// Set new charges
for (int i = 0; i != CutParm->Natom(); i++)
CutParm->SetAtom(i).SetCharge( CutCharges[i] );
int err = 0;
Trajout_Single tout;
if (tout.PrepareTrajWrite(outfilename, "multi", CutParm, CoordinateInfo(), 1,
TrajectoryFile::MOL2FILE))
{
mprinterr("Error: Could not set up cut mol2 file %s\n", outfilename.c_str());
err = 1;
} else {
tout.WriteSingle(frameNum, CutFrame);
tout.EndTraj();
}
delete CutParm;
return err;
}
// Analysis_Hist::Analyze()
Analysis::RetType Analysis_Hist::Analyze() {
// Set up dimensions
// Size of histdata and dimensionArgs should be the same
size_t total_bins = 0UL;
for (unsigned int hd = 0; hd < N_dimensions_; hd++) {
if ( setupDimension(dimensionArgs_[hd], *(histdata_[hd]), total_bins) )
return Analysis::ERR;
}
// dimensionArgs no longer needed
dimensionArgs_.clear();
// Check that the number of data points in each dimension are equal
std::vector<DataSet_1D*>::iterator ds = histdata_.begin();
size_t Ndata = (*ds)->Size();
++ds;
for (; ds != histdata_.end(); ++ds)
{
//mprintf("DEBUG: DS %s size %i\n",histdata[hd]->Name(),histdata[hd]->Xmax()+1);
if (Ndata != (*ds)->Size()) {
mprinterr("Error: Hist: Dataset %s has inconsistent # data points (%zu), expected %zu.\n",
(*ds)->legend(), (*ds)->Size(), Ndata);
return Analysis::ERR;
}
}
mprintf("\tHist: %zu data points in each dimension.\n", Ndata);
if (calcAMD_ && Ndata != amddata_->Size()) {
mprinterr("Error: Hist: AMD data set size (%zu) does not match # expected data points (%zu).\n",
amddata_->Size(), Ndata);
return Analysis::ERR;
}
// Allocate bins
mprintf("\tHist: Allocating histogram, total bins = %zu\n", total_bins);
Bins_.resize( total_bins, 0.0 );
// Bin data
for (size_t n = 0; n < Ndata; n++) {
long int index = 0;
HdimType::const_iterator dim = dimensions_.begin();
OffType::const_iterator bOff = binOffsets_.begin();
for (std::vector<DataSet_1D*>::iterator ds = histdata_.begin();
ds != histdata_.end(); ++ds, ++dim, ++bOff)
{
double dval = (*ds)->Dval( n );
// Check if data is out of bounds for this dimension.
if (dval > dim->Max() || dval < dim->Min()) {
index = -1L;
break;
}
// Calculate index for this particular dimension (idx)
long int idx = (long int)((dval - dim->Min()) / dim->Step());
if (debug_>1) mprintf(" [%s:%f (%li)],", dim->label(), dval, idx);
// Calculate overall index in Bins, offset has already been calcd.
index += (idx * (*bOff));
}
// If index was successfully calculated, populate bin
if (index > -1L && index < (long int)Bins_.size()) {
if (debug_ > 1) mprintf(" |index=%li",index);
if (calcAMD_)
Bins_[index] += exp( amddata_->Dval(n) );
else
Bins_[index]++;
} else {
mprintf("\tWarning: Frame %zu Coordinates out of bounds (%li)\n", n+1, index);
}
if (debug_>1) mprintf("}\n");
}
// Calc free energy if requested
if (calcFreeE_) CalcFreeE();
// Normalize if requested
if (normalize_ != NO_NORM) Normalize();
if (nativeOut_) {
// Use Histogram built-in output
PrintBins();
} else {
// Using DataFileList framework, set-up labels etc.
if (N_dimensions_ == 1) {
DataSet_double& dds = static_cast<DataSet_double&>( *hist_ );
// Since Allocate1D only reserves data, use assignment op.
dds = Bins_;
hist_->SetDim(Dimension::X, dimensions_[0]);
} else if (N_dimensions_ == 2) {
DataSet_MatrixDbl& mds = static_cast<DataSet_MatrixDbl&>( *hist_ );
mds.Allocate2D( dimensions_[0].Bins(), dimensions_[1].Bins() );
std::copy( Bins_.begin(), Bins_.end(), mds.begin() );
hist_->SetDim(Dimension::X, dimensions_[0]);
hist_->SetDim(Dimension::Y, dimensions_[1]);
outfile_->ProcessArgs("noxcol usemap nolabels");
} else if (N_dimensions_ == 3) {
DataSet_GridFlt& gds = static_cast<DataSet_GridFlt&>( *hist_ );
//gds.Allocate3D( dimensions_[0].Bins(), dimensions_[1].Bins(), dimensions_[2].Bins() );
gds.Allocate_N_O_D( dimensions_[0].Bins(), dimensions_[1].Bins(), dimensions_[2].Bins(),
Vec3(dimensions_[0].Min(), dimensions_[1].Min(), dimensions_[2].Min()),
Vec3(dimensions_[0].Step(), dimensions_[1].Step(), dimensions_[2].Step())
);
//std::copy( Bins_.begin(), Bins_.end(), gds.begin() );
// FIXME: Copy will not work since in grids data is ordered with Z
// changing fastest. Should the ordering in grid be changed?
size_t idx = 0;
for (size_t z = 0; z < gds.NZ(); z++)
for (size_t y = 0; y < gds.NY(); y++)
for (size_t x = 0; x < gds.NX(); x++)
gds.SetElement( x, y, z, (float)Bins_[idx++] );
hist_->SetDim(Dimension::X, dimensions_[0]);
hist_->SetDim(Dimension::Y, dimensions_[1]);
hist_->SetDim(Dimension::Z, dimensions_[2]);
outfile_->ProcessArgs("noxcol usemap nolabels");
// Create pseudo-topology/trajectory
if (!traj3dName_.empty()) {
Topology pseudo;
pseudo.AddTopAtom(Atom("H3D", 0), Residue("H3D", 1, ' ', ' '));
pseudo.CommonSetup();
if (!parmoutName_.empty()) {
ParmFile pfile;
if (pfile.WriteTopology( pseudo, parmoutName_, ParmFile::UNKNOWN_PARM, 0 ))
mprinterr("Error: Could not write pseudo topology to '%s'\n", parmoutName_.c_str());
}
Trajout_Single out;
if (out.PrepareTrajWrite(traj3dName_, ArgList(), &pseudo, CoordinateInfo(),
Ndata, traj3dFmt_) == 0)
{
Frame outFrame(1);
for (size_t i = 0; i < Ndata; ++i) {
outFrame.ClearAtoms();
outFrame.AddVec3( Vec3(histdata_[0]->Dval(i),
histdata_[1]->Dval(i),
histdata_[2]->Dval(i)) );
out.WriteSingle(i, outFrame);
}
out.EndTraj();
} else
mprinterr("Error: Could not set up '%s' for write.\n", traj3dName_.c_str());
}
}
}
return Analysis::OK;
}
int SequenceAlign(CpptrajState& State, ArgList& argIn) {
std::string blastfile = argIn.GetStringKey("blastfile");
if (blastfile.empty()) {
mprinterr("Error: 'blastfile' must be specified.\n");
return 1;
}
ReferenceFrame qref = State.DSL()->GetReferenceFrame(argIn);
if (qref.error() || qref.empty()) {
mprinterr("Error: Must specify reference structure for query.\n");
return 1;
}
std::string outfilename = argIn.GetStringKey("out");
if (outfilename.empty()) {
mprinterr("Error: Must specify output file.\n");
return 1;
}
TrajectoryFile::TrajFormatType fmt = TrajectoryFile::GetFormatFromArg(argIn);
if (fmt != TrajectoryFile::PDBFILE && fmt != TrajectoryFile::MOL2FILE)
fmt = TrajectoryFile::PDBFILE; // Default to PDB
int smaskoffset = argIn.getKeyInt("smaskoffset", 0) + 1;
int qmaskoffset = argIn.getKeyInt("qmaskoffset", 0) + 1;
// Load blast file
mprintf("\tReading BLAST alignment from '%s'\n", blastfile.c_str());
BufferedLine infile;
if (infile.OpenFileRead( blastfile )) return 1;
// Seek down to first Query line.
const char* ptr = infile.Line();
bool atFirstQuery = false;
while (ptr != 0) {
if (*ptr == 'Q') {
if ( strncmp(ptr, "Query", 5) == 0 ) {
atFirstQuery = true;
break;
}
}
ptr = infile.Line();
}
if (!atFirstQuery) {
mprinterr("Error: 'Query' not found.\n");
return 1;
}
// Read alignment. Replacing query with subject.
typedef std::vector<char> Carray;
typedef std::vector<int> Iarray;
Carray Query; // Query residues
Carray Sbjct; // Sbjct residues
Iarray Smap; // Smap[Sbjct index] = Query index
while (ptr != 0) {
const char* qline = ptr; // query line
const char* aline = infile.Line(); // alignment line
const char* sline = infile.Line(); // subject line
if (aline == 0 || sline == 0) {
mprinterr("Error: Missing alignment line or subject line after Query:\n");
mprinterr("Error: %s", qline);
return 1;
}
for (int idx = 12; qline[idx] != ' '; idx++) {
if (qline[idx] == '-') {
// Sbjct does not have corresponding res in Query
Smap.push_back(-1);
Sbjct.push_back( sline[idx] );
} else if (sline[idx] == '-') {
// Query does not have a corresponding res in Sbjct
Query.push_back( qline[idx] );
} else {
// Direct Query to Sbjct map
Smap.push_back( Query.size() );
Sbjct.push_back( sline[idx] );
Query.push_back( qline[idx] );
}
}
// Scan to next Query
ptr = infile.Line();
while (ptr != 0) {
if (*ptr == 'Q') {
if ( strncmp(ptr, "Query", 5) == 0 ) break;
}
ptr = infile.Line();
}
}
// DEBUG
std::string SmaskExp, QmaskExp;
if (State.Debug() > 0) mprintf(" Map of Sbjct to Query:\n");
for (int sres = 0; sres != (int)Sbjct.size(); sres++) {
if (State.Debug() > 0)
mprintf("%-i %3s %i", sres+smaskoffset, Residue::ConvertResName(Sbjct[sres]),
Smap[sres]+qmaskoffset);
const char* qres = "";
if (Smap[sres] != -1) {
qres = Residue::ConvertResName(Query[Smap[sres]]);
if (SmaskExp.empty())
SmaskExp.assign( integerToString(sres+smaskoffset) );
else
SmaskExp.append( "," + integerToString(sres+smaskoffset) );
if (QmaskExp.empty())
QmaskExp.assign( integerToString(Smap[sres]+qmaskoffset) );
else
QmaskExp.append( "," + integerToString(Smap[sres]+qmaskoffset) );
}
if (State.Debug() > 0) mprintf(" %3s\n", qres);
}
mprintf("Smask: %s\n", SmaskExp.c_str());
mprintf("Qmask: %s\n", QmaskExp.c_str());
// Check that query residues match reference.
for (unsigned int sres = 0; sres != Sbjct.size(); sres++) {
int qres = Smap[sres];
if (qres != -1) {
if (Query[qres] != qref.Parm().Res(qres).SingleCharName()) {
mprintf("Warning: Potential residue mismatch: Query %s reference %s\n",
Residue::ConvertResName(Query[qres]), qref.Parm().Res(qres).c_str());
}
}
}
// Build subject using coordinate from reference.
//AtomMask sMask; // Contain atoms that should be in sTop
Topology sTop;
Frame sFrame;
Iarray placeHolder; // Atom indices of placeholder residues.
for (unsigned int sres = 0; sres != Sbjct.size(); sres++) {
int qres = Smap[sres];
NameType SresName( Residue::ConvertResName(Sbjct[sres]) );
if (qres != -1) {
Residue const& QR = qref.Parm().Res(qres);
Residue SR(SresName, sres+1, ' ', QR.ChainID());
if (Query[qres] == Sbjct[sres]) { // Exact match. All non-H atoms.
for (int qat = QR.FirstAtom(); qat != QR.LastAtom(); qat++)
{
if (qref.Parm()[qat].Element() != Atom::HYDROGEN)
sTop.AddTopAtom( qref.Parm()[qat], SR );
sFrame.AddXYZ( qref.Coord().XYZ(qat) );
//sMask.AddAtom(qat);
}
} else { // Partial match. Copy only backbone and CB.
for (int qat = QR.FirstAtom(); qat != QR.LastAtom(); qat++)
{
if ( qref.Parm()[qat].Name().Match("N" ) ||
qref.Parm()[qat].Name().Match("CA") ||
qref.Parm()[qat].Name().Match("CB") ||
qref.Parm()[qat].Name().Match("C" ) ||
qref.Parm()[qat].Name().Match("O" ) )
{
sTop.AddTopAtom( qref.Parm()[qat], SR );
sFrame.AddXYZ( qref.Coord().XYZ(qat) );
}
}
}
} else {
// Residue in query does not exist for subject. Just put placeholder CA for now.
Vec3 Zero(0.0);
placeHolder.push_back( sTop.Natom() );
sTop.AddTopAtom( Atom("CA", "C "), Residue(SresName, sres+1, ' ', ' ') );
sFrame.AddXYZ( Zero.Dptr() );
}
}
//sTop.PrintAtomInfo("*");
mprintf("\tPlaceholder residue indices:");
for (Iarray::const_iterator p = placeHolder.begin(); p != placeHolder.end(); ++p)
mprintf(" %i", *p + 1);
mprintf("\n");
// Try to give placeholders more reasonable coordinates.
if (!placeHolder.empty()) {
Iarray current_indices;
unsigned int pidx = 0;
while (pidx < placeHolder.size()) {
if (current_indices.empty()) {
current_indices.push_back( placeHolder[pidx++] );
// Search for the end of this segment
for (; pidx != placeHolder.size(); pidx++) {
if (placeHolder[pidx] - current_indices.back() > 1) break;
current_indices.push_back( placeHolder[pidx] );
}
// DEBUG
mprintf("\tSegment:");
for (Iarray::const_iterator it = current_indices.begin();
it != current_indices.end(); ++it)
mprintf(" %i", *it + 1);
// Get coordinates of residues bordering segment.
int prev_res = sTop[current_indices.front()].ResNum() - 1;
int next_res = sTop[current_indices.back() ].ResNum() + 1;
mprintf(" (prev_res=%i, next_res=%i)\n", prev_res+1, next_res+1);
Vec3 prev_crd(sFrame.XYZ(current_indices.front() - 1));
Vec3 next_crd(sFrame.XYZ(current_indices.back() + 1));
prev_crd.Print("prev_crd");
next_crd.Print("next_crd");
Vec3 crd_step = (next_crd - prev_crd) / (double)(current_indices.size()+1);
crd_step.Print("crd_step");
double* xyz = sFrame.xAddress() + (current_indices.front() * 3);
for (unsigned int i = 0; i != current_indices.size(); i++, xyz += 3) {
prev_crd += crd_step;
xyz[0] = prev_crd[0];
xyz[1] = prev_crd[1];
xyz[2] = prev_crd[2];
}
current_indices.clear();
}
}
}
//Topology* sTop = qref.Parm().partialModifyStateByMask( sMask );
//if (sTop == 0) return 1;
//Frame sFrame(qref.Coord(), sMask);
// Write output traj
Trajout_Single trajout;
if (trajout.PrepareTrajWrite(outfilename, argIn, &sTop, CoordinateInfo(), 1, fmt)) return 1;
if (trajout.WriteSingle(0, sFrame)) return 1;
trajout.EndTraj();
return 0;
}
// Exec_PermuteDihedrals::RandomizeAngles()
void Exec_PermuteDihedrals::RandomizeAngles(Frame& currentFrame, Topology const& topIn) {
Matrix_3x3 rotationMatrix;
# ifdef DEBUG_PERMUTEDIHEDRALS
// DEBUG
int debugframenum=0;
Trajout_Single DebugTraj;
DebugTraj.PrepareTrajWrite("debugtraj.nc",ArgList(),(Topology*)&topIn,
CoordinateInfo(), BB_dihedrals_.size()*max_factor_,
TrajectoryFile::AMBERNETCDF);
DebugTraj.WriteSingle(debugframenum++,currentFrame);
# endif
int next_resnum;
int bestLoop = 0;
int number_of_rotations = 0;
// Set max number of rotations to try.
int max_rotations = (int)BB_dihedrals_.size();
max_rotations *= max_factor_;
// Loop over all dihedrals
std::vector<PermuteDihedralsType>::const_iterator next_dih = BB_dihedrals_.begin();
next_dih++;
for (std::vector<PermuteDihedralsType>::const_iterator dih = BB_dihedrals_.begin();
dih != BB_dihedrals_.end();
++dih, ++next_dih)
{
++number_of_rotations;
// Get the residue atom of the next dihedral. Residues up to and
// including this residue will be checked for bad clashes
if (next_dih != BB_dihedrals_.end())
next_resnum = next_dih->resnum;
else
next_resnum = dih->resnum - 1;
// Set axis of rotation
Vec3 axisOfRotation = currentFrame.SetAxisOfRotation(dih->atom1, dih->atom2);
// Generate random value to rotate by in radians
// Guaranteed to rotate by at least 1 degree.
// NOTE: could potentially rotate 360 - prevent?
// FIXME: Just use 2PI and rn_gen, get everything in radians
double theta_in_degrees = ((int)(RN_.rn_gen()*100000) % 360) + 1;
double theta_in_radians = theta_in_degrees * Constants::DEGRAD;
// Calculate rotation matrix for random theta
rotationMatrix.CalcRotationMatrix(axisOfRotation, theta_in_radians);
int loop_count = 0;
double clash = 0;
double bestClash = 0;
if (debug_>0) mprintf("DEBUG: Rotating dihedral %zu res %8i:\n", dih - BB_dihedrals_.begin(),
dih->resnum+1);
bool rotate_dihedral = true;
while (rotate_dihedral) {
if (debug_>0) {
mprintf("\t%8i %12s %12s, +%.2lf degrees (%i).\n",dih->resnum+1,
topIn.AtomMaskName(dih->atom1).c_str(),
topIn.AtomMaskName(dih->atom2).c_str(),
theta_in_degrees,loop_count);
}
// Rotate around axis
currentFrame.Rotate(rotationMatrix, dih->Rmask);
# ifdef DEBUG_PERMUTEDIHEDRALS
// DEBUG
DebugTraj.WriteSingle(debugframenum++,currentFrame);
# endif
// If we dont care about sterics exit here
if (!check_for_clashes_) break;
// Check resulting structure for issues
int checkresidue;
if (!checkAllResidues_)
checkresidue = CheckResidue(currentFrame, topIn, *dih, next_resnum, clash);
else
checkresidue = CheckResidue(currentFrame, topIn, *dih, topIn.Nres(), clash);
if (checkresidue==0)
rotate_dihedral = false;
else if (checkresidue==-1) {
if (dih - BB_dihedrals_.begin() < 2) {
mprinterr("Error: Cannot backtrack; initial structure already has clashes.\n");
number_of_rotations = max_rotations + 1;
} else {
dih--; // 0
dih--; // -1
next_dih = dih;
next_dih++;
if (debug_>0)
mprintf("\tCannot resolve clash with further rotations, trying previous again.\n");
}
break;
}
if (clash > bestClash) {bestClash = clash; bestLoop = loop_count;}
//n_problems = CheckResidues( currentFrame, second_atom );
//if (n_problems > -1) {
// mprintf("%i\tCheckResidues: %i problems.\n",frameNum,n_problems);
// rotate_dihedral = false;
//} else if (loop_count==0) {
if (loop_count==0 && rotate_dihedral) {
if (debug_>0)
mprintf("\tTrying dihedral increments of +%i\n",increment_);
// Instead of a new random dihedral, try increments
theta_in_degrees = (double)increment_;
theta_in_radians = theta_in_degrees * Constants::DEGRAD;
// Calculate rotation matrix for new theta
rotationMatrix.CalcRotationMatrix(axisOfRotation, theta_in_radians);
}
++loop_count;
if (loop_count == max_increment_) {
if (debug_>0)
mprintf("%i iterations! Best clash= %.3lf at %i\n",max_increment_,
sqrt(bestClash),bestLoop);
if (dih - BB_dihedrals_.begin() < backtrack_) {
mprinterr("Error: Cannot backtrack; initial structure already has clashes.\n");
number_of_rotations = max_rotations + 1;
} else {
for (int bt = 0; bt < backtrack_; bt++)
dih--;
next_dih = dih;
next_dih++;
if (debug_>0)
mprintf("\tCannot resolve clash with further rotations, trying previous %i again.\n",
backtrack_ - 1);
}
break;
// Calculate how much to rotate back in order to get to best clash
/*int num_back = bestLoop - 359;
theta_in_degrees = (double) num_back;
theta_in_radians = theta_in_degrees * Constants::DEGRAD;
// Calculate rotation matrix for theta
calcRotationMatrix(rotationMatrix, axisOfRotation, theta_in_radians);
// Rotate back to best clash
frm.Frm().RotateAroundAxis(rotationMatrix, theta_in_radians, dih->Rmask);
// DEBUG
DebugTraj.WriteFrame(debugframenum++,currentParm,*currentFrame);
// Sanity check
CheckResidue(currentFrame, *dih, second_atom, &clash);
rotate_dihedral=false;*/
//DebugTraj.EndTraj();
//return 1;
}
} // End dihedral rotation loop
// Safety valve - number of defined dihedrals times * maxfactor
if (number_of_rotations > max_rotations) {
mprinterr("Error: # of rotations (%i) exceeds max rotations (%i), exiting.\n",
number_of_rotations, max_rotations);
//# ifdef DEBUG_PERMUTEDIHEDRALS
// DebugTraj.EndTraj();
//# endif
// Return gracefully for now
break;
//return 1;
}
} // End loop over dihedrals
# ifdef DEBUG_PERMUTEDIHEDRALS
DebugTraj.EndTraj();
mprintf("\tNumber of rotations %i, expected %u\n",number_of_rotations,BB_dihedrals_.size());
# endif
}
// ----- M A I N ---------------------------------------------------------------
int main(int argc, char** argv) {
SetWorldSilent(true); // No STDOUT output from cpptraj routines.
std::string topname, crdname, title, bres, pqr, sybyltype, writeconect;
std::string aatm(" pdbatom"), ter_opt(" terbyres"), box(" sg \"P 1\"");
TrajectoryFile::TrajFormatType fmt = TrajectoryFile::PDBFILE;
bool ctr_origin = false;
bool useExtendedInfo = false;
int res_offset = 0;
int debug = 0;
int numSoloArgs = 0;
for (int i = 1; i < argc; ++i) {
std::string arg( argv[i] );
if (arg == "-p" && i+1 != argc && topname.empty()) // Topology
topname = std::string( argv[++i] );
else if (arg == "-c" && i+1 != argc && crdname.empty()) // Coords
crdname = std::string( argv[++i] );
else if (arg == "-tit" && i+1 != argc && title.empty()) // Title
title = " title " + std::string( argv[++i] );
else if (arg == "-offset" && i+1 != argc) // Residue # offset
res_offset = convertToInteger( argv[++i] );
else if ((arg == "-d" || arg == "--debug") && i+1 != argc) // Debug level
debug = convertToInteger( argv[++i] );
else if (arg == "-h" || arg == "--help") { // Help
Help(argv[0], true);
return 0;
} else if (arg == "-v" || arg == "--version") { // Version info
WriteVersion();
return 0;
} else if (arg == "-aatm") // Amber atom names, include extra pts
aatm.assign(" include_ep");
else if (arg == "-sybyl") // Amber atom types to SYBYL
sybyltype.assign(" sybyltype");
else if (arg == "-conect") // Write CONECT records from bond info
writeconect.assign(" conect");
else if (arg == "-ep") // PDB atom names, include extra pts
aatm.append(" include_ep");
else if (arg == "-bres") // PDB residue names
bres.assign(" pdbres");
else if (arg == "-ext") // Use extended PDB info from Topology
useExtendedInfo = true;
else if (arg == "-ctr") // Center on origin
ctr_origin = true;
else if (arg == "-noter") // No TER cards
ter_opt.assign(" noter");
else if (arg == "-nobox") // No CRYST1 record
box.assign(" nobox");
else if (arg == "-pqr") { // Charge/Radii in occ/bfactor cols
pqr.assign(" dumpq");
++numSoloArgs;
} else if (arg == "-mol2") { // output as mol2
fmt = TrajectoryFile::MOL2FILE;
++numSoloArgs;
} else if (Unsupported(arg)) {
mprinterr("Error: Option '%s' is not yet supported.\n\n", arg.c_str());
return 1;
} else {
mprinterr("Error: Unrecognized option '%s'\n", arg.c_str());
Help(argv[0], false);
return 1;
}
}
if (debug > 0) WriteVersion();
// Check command line for errors.
if (topname.empty()) topname.assign("prmtop");
if (debug > 0 && crdname.empty())
mprinterr("| Reading Amber restart from STDIN\n");
if (numSoloArgs > 1) {
mprinterr("Error: Only one alternate output format option may be specified (found %i)\n",
numSoloArgs);
Help(argv[0], true);
return 1;
}
if (!sybyltype.empty() && fmt != TrajectoryFile::MOL2FILE) {
mprinterr("Warning: -sybyl is only valid for MOL2 file output.\n");
sybyltype.clear();
}
if (debug > 0) {
mprinterr("Warning: debug is %i; debug info will be written to STDOUT.\n", debug);
SetWorldSilent(false);
}
// Topology
ParmFile pfile;
Topology parm;
if (pfile.ReadTopology(parm, topname, debug)) {
if (topname == "prmtop") Help(argv[0], false);
return 1;
}
if (!useExtendedInfo)
parm.ResetPDBinfo();
if (res_offset != 0)
for (int r = 0; r < parm.Nres(); r++)
parm.SetRes(r).SetOriginalNum( parm.Res(r).OriginalResNum() + res_offset );
ArgList trajArgs;
// Input coords
Frame TrajFrame;
CoordinateInfo cInfo;
if (!crdname.empty()) {
Trajin_Single trajin;
if (trajin.SetupTrajRead(crdname, trajArgs, &parm)) return 1;
cInfo = trajin.TrajCoordInfo();
TrajFrame.SetupFrameV(parm.Atoms(), cInfo);
trajin.BeginTraj();
if (trajin.ReadTrajFrame(0, TrajFrame)) return 1;
trajin.EndTraj();
} else {
// Assume Amber restart from STDIN
// Check that input is from a redirect.
if ( isatty(fileno(stdin)) ) {
mprinterr("Error: No coordinates specified with '-c' and no STDIN '<'.\n");
return 1;
}
Traj_AmberRestart restartIn;
restartIn.SetDebug( debug );
//restartIn.processReadArgs( trajArgs );
int total_frames = restartIn.setupTrajin("", &parm);
if (total_frames < 1) return 1;
cInfo = restartIn.CoordInfo();
TrajFrame.SetupFrameV(parm.Atoms(), cInfo);
if (restartIn.openTrajin()) return 1;
if (restartIn.readFrame(0, TrajFrame)) return 1;
restartIn.closeTraj();
}
if (ctr_origin)
TrajFrame.CenterOnOrigin(false);
// Output coords
Trajout_Single trajout;
trajArgs.SetList( aatm + bres + pqr + title + ter_opt + box + sybyltype + writeconect, " " );
if ( trajout.PrepareStdoutTrajWrite(trajArgs, &parm, cInfo, 1, fmt) ) return 1;
trajout.WriteSingle(0, TrajFrame);
trajout.EndTraj();
return 0;
}
