// CONSTRUCTOR
DataSet_Modes::DataSet_Modes() :
// 0 dim indicates DataSet-specific write
DataSet(MODES, GENERIC, TextFormat(TextFormat::DOUBLE, 10, 5), 0),
evalues_(0),
evectors_(0),
nmodes_(0),
vecsize_(0),
reduced_(false)
{}
void SyntaxHighlighter::loadUserFormat(const QString& path) {
QJsonDocument doc = _LoadJson(path);
_formatMap.clear();
QJsonObject root = doc.object();
auto itr = root.find(JEnt::Highlight::highlights);
if(itr != root.end()) {
QJsonObject ent = itr.value().toObject();
for(auto itr2 = ent.begin() ; itr2 != ent.end() ; itr2++)
_formatMap.emplace(itr2.key().toStdString(), TextFormat(itr2.value().toObject()));
}
_refreshPairV();
}
DataSet_RemLog::DataSet_RemLog() :
// 0 dim indicates DataSet-specific write
DataSet(REMLOG, GENERIC, TextFormat(TextFormat::DOUBLE, 10, 4), 0)
{}
// CONSTRUCTOR
DataSet_Vector::DataSet_Vector() :
DataSet(VECTOR, GENERIC, TextFormat(TextFormat::DOUBLE, 8, 4, 6), 1),
order_(0) {}
// Analysis_Modes::Setup()
Analysis::RetType Analysis_Modes::Setup(ArgList& analyzeArgs, AnalysisSetup& setup, int debugIn)
{
debug_ = debugIn;
// Analysis type
if (analyzeArgs.hasKey("fluct"))
type_ = FLUCT;
else if (analyzeArgs.hasKey("displ"))
type_ = DISPLACE;
else if (analyzeArgs.hasKey("corr"))
type_ = CORR;
else if (analyzeArgs.Contains("trajout"))
type_ = TRAJ;
else if (analyzeArgs.hasKey("eigenval"))
type_ = EIGENVAL;
else if (analyzeArgs.hasKey("rmsip"))
type_ = RMSIP;
else {
mprinterr("Error: No analysis type specified.\n");
return Analysis::ERR;
}
// Get modes name
std::string modesfile = analyzeArgs.GetStringKey("name");
if (modesfile.empty()) {
// Check for deprecated args
CheckDeprecated(analyzeArgs, modesfile, "file");
CheckDeprecated(analyzeArgs, modesfile, "stack");
if (modesfile.empty()) {
mprinterr("Error: No 'name <modes data set name>' argument given.\n");
return Analysis::ERR;
}
}
// Get second modes name for RMSIP
std::string modesfile2 = analyzeArgs.GetStringKey("name2");
if (type_ == RMSIP) {
if (modesfile2.empty()) {
mprinterr("Error: 'rmsip' requires second modes data 'name2 <modes>'\n");
return Analysis::ERR;
}
} else
modesfile2.clear();
// Get topology for TRAJ/CORR
Topology* analyzeParm = setup.DSL().GetTopology( analyzeArgs );
if (type_ == TRAJ ) {
// Get trajectory format args for projected traj
beg_ = analyzeArgs.getKeyInt("beg",1) - 1; // Args start at 1
std::string tOutName = analyzeArgs.GetStringKey("trajout");
if (tOutName.empty()) {
mprinterr("Error: Require output trajectory filename, 'trajout <name>'\n");
return Analysis::ERR;
}
TrajectoryFile::TrajFormatType tOutFmt = TrajectoryFile::UNKNOWN_TRAJ;
if ( analyzeArgs.Contains("trajoutfmt") )
tOutFmt = TrajectoryFile::GetFormatFromString( analyzeArgs.GetStringKey("trajoutfmt") );
if (analyzeParm == 0) {
mprinterr("Error: Could not get topology for output trajectory.\n");
return Analysis::ERR;
}
AtomMask tOutMask( analyzeArgs.GetStringKey("trajoutmask") );
if ( analyzeParm->SetupIntegerMask( tOutMask ) || tOutMask.None() ) {
mprinterr("Error: Could not setup output trajectory mask.\n");
return Analysis::ERR;
}
tOutMask.MaskInfo();
// Strip topology to match mask.
if (tOutParm_ != 0) delete tOutParm_;
tOutParm_ = analyzeParm->modifyStateByMask( tOutMask );
if (tOutParm_ == 0) {
mprinterr("Error: Could not create topology to match mask.\n");
return Analysis::ERR;
}
// Setup output traj
if (trajout_.InitTrajWrite( tOutName, ArgList(), tOutFmt ) != 0) {
mprinterr("Error: Could not init output trajectory.\n");
return Analysis::ERR;
}
// Get min and max for PC
pcmin_ = analyzeArgs.getKeyDouble("pcmin", -10.0);
pcmax_ = analyzeArgs.getKeyDouble("pcmax", 10.0);
if (pcmax_ < pcmin_ || pcmax_ - pcmin_ < Constants::SMALL) {
mprinterr("Error: pcmin must be less than pcmax\n");
return Analysis::ERR;
}
tMode_ = analyzeArgs.getKeyInt("tmode", 1);
} else {
// Args for everything else
beg_ = analyzeArgs.getKeyInt("beg",7) - 1; // Args start at 1
bose_ = analyzeArgs.hasKey("bose");
calcAll_ = analyzeArgs.hasKey("calcall");
}
end_ = analyzeArgs.getKeyInt("end", 50);
factor_ = analyzeArgs.getKeyDouble("factor",1.0);
std::string setname = analyzeArgs.GetStringKey("setname");
// Check if modes name exists on the stack
modinfo_ = (DataSet_Modes*)setup.DSL().FindSetOfType( modesfile, DataSet::MODES );
if (modinfo_ == 0) {
mprinterr("Error: '%s' not found: %s\n", modesfile.c_str(), DataSet_Modes::DeprecateFileMsg);
return Analysis::ERR;
}
if (!modesfile2.empty()) {
modinfo2_ = (DataSet_Modes*)setup.DSL().FindSetOfType( modesfile2, DataSet::MODES );
if (modinfo2_ == 0) {
mprinterr("Error: Set %s not found.\n", modesfile2.c_str());
return Analysis::ERR;
}
}
// Check modes type for specified analysis
if (type_ == FLUCT || type_ == DISPLACE || type_ == CORR || type_ == TRAJ) {
if (modinfo_->Meta().ScalarType() != MetaData::COVAR &&
modinfo_->Meta().ScalarType() != MetaData::MWCOVAR)
{
mprinterr("Error: Modes must be of type COVAR or MWCOVAR for %s.\n",
analysisTypeString[type_]);
return Analysis::ERR;
}
}
// Get output filename for types that use DataSets
std::string outfilename = analyzeArgs.GetStringKey("out"); // TODO all datafile?
DataFile* dataout = 0;
if (type_ == FLUCT || type_ == DISPLACE || type_ == EIGENVAL || type_ == RMSIP)
dataout = setup.DFL().AddDataFile( outfilename, analyzeArgs );
else if (type_ == CORR) {
// CORR-specific setup
outfile_ = setup.DFL().AddCpptrajFile( outfilename, "Modes analysis",
DataFileList::TEXT, true );
if (outfile_ == 0) return Analysis::ERR;
// Get list of atom pairs
if (analyzeParm == 0) {
mprinterr("Error: 'corr' requires topology.\n");
return Analysis::ERR;
}
std::string maskexp = analyzeArgs.GetStringKey("mask1");
if (maskexp.empty()) {
while (analyzeArgs.hasKey("maskp")) {
// Next two arguments should be one-atom masks
std::string a1mask = analyzeArgs.GetMaskNext();
std::string a2mask = analyzeArgs.GetMaskNext();
if (a1mask.empty() || a2mask.empty()) {
mprinterr("Error: For 'corr' two 1-atom masks are expected.\n");
return Analysis::ERR;
}
// Check that each mask is just 1 atom
AtomMask m1( a1mask );
AtomMask m2( a2mask );
analyzeParm->SetupIntegerMask( m1 );
analyzeParm->SetupIntegerMask( m2 );
if ( m1.Nselected()==1 && m2.Nselected()==1 )
// Store atom pair
atompairStack_.push_back( std::pair<int,int>( m1[0], m2[0] ) );
else {
mprinterr("Error: For 'corr', masks should specify only one atom.\n"
"\tM1[%s]=%i atoms, M2[%s]=%i atoms.\n", m1.MaskString(), m1.Nselected(),
m2.MaskString(), m2.Nselected());
return Analysis::ERR;
}
}
} else {
AtomMask mask1( maskexp );
maskexp = analyzeArgs.GetStringKey("mask2");
if (maskexp.empty()) {
mprinterr("Error: 'mask2' must be specified if 'mask1' is.\n");
return Analysis::ERR;
}
AtomMask mask2( maskexp );
if ( analyzeParm->SetupIntegerMask( mask1 ) ) return Analysis::ERR;
if ( analyzeParm->SetupIntegerMask( mask2 ) ) return Analysis::ERR;
mask1.MaskInfo();
mask2.MaskInfo();
if (mask1.None() || mask2.None()) {
mprinterr("Error: One or both masks are empty.\n");
return Analysis::ERR;
}
if (mask1.Nselected() != mask2.Nselected()) {
mprinterr("Error: # atoms in mask 1 not equal to # atoms in mask 2.\n");
return Analysis::ERR;
}
for (int idx = 0; idx != mask1.Nselected(); idx++)
atompairStack_.push_back( std::pair<int,int>( mask1[idx], mask2[idx] ) );
}
if ( atompairStack_.empty() ) {
mprinterr("Error: No atom pairs found (use 'maskp' or 'mask1'/'mask2' keywords.)\n");
return Analysis::ERR;
}
}
// Set up data sets
Dimension Xdim;
if (type_ == FLUCT) {
if (setname.empty()) setname = setup.DSL().GenerateDefaultName("FLUCT");
MetaData md(setname, "rmsX");
OutSets_.resize( 4, 0 );
OutSets_[RMSX] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("rmsY");
OutSets_[RMSY] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("rmsZ");
OutSets_[RMSZ] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("rms");
OutSets_[RMS] = setup.DSL().AddSet( DataSet::DOUBLE, md );
Xdim = Dimension(1, 1, "Atom_no.");
} else if (type_ == DISPLACE) {
if (setname.empty()) setname = setup.DSL().GenerateDefaultName("DISPL");
MetaData md(setname, "displX");
OutSets_.resize( 3, 0 );
OutSets_[RMSX] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("displY");
OutSets_[RMSY] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("displZ");
OutSets_[RMSZ] = setup.DSL().AddSet( DataSet::DOUBLE, md );
Xdim = Dimension(1, 1, "Atom_no.");
} else if (type_ == EIGENVAL) {
if (setname.empty()) setname = setup.DSL().GenerateDefaultName("XEVAL");
MetaData md(setname, "Frac");
OutSets_.resize( 3, 0 );
OutSets_[0] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("Cumulative");
OutSets_[1] = setup.DSL().AddSet( DataSet::DOUBLE, md );
md.SetAspect("Eigenval");
OutSets_[2] = setup.DSL().AddSet( DataSet::DOUBLE, md );
Xdim = Dimension( 1, 1, "Mode" );
} else if (type_ == RMSIP) {
if (setname.empty()) setname = setup.DSL().GenerateDefaultName("RMSIP");
OutSets_.push_back( setup.DSL().AddSet( DataSet::DOUBLE, setname ) );
if (dataout != 0) dataout->ProcessArgs("noxcol");
OutSets_[0]->SetupFormat() = TextFormat(TextFormat::GDOUBLE);
OutSets_[0]->SetLegend( modinfo_->Meta().Legend() + "_X_" + modinfo2_->Meta().Legend() );
}
for (std::vector<DataSet*>::const_iterator set = OutSets_.begin(); set != OutSets_.end(); ++set)
{
if (*set == 0) return Analysis::ERR;
if (dataout != 0) dataout->AddDataSet( *set );
(*set)->SetDim(Dimension::X, Xdim);
}
// Status
mprintf(" ANALYZE MODES: Calculating %s using modes from %s",
analysisTypeString[type_], modinfo_->legend());
if ( type_ != TRAJ ) {
if (type_ != EIGENVAL)
mprintf(", modes %i to %i", beg_+1, end_);
if (outfile_ != 0)
mprintf("\n\tResults are written to %s\n", outfile_->Filename().full());
else if (dataout != 0)
mprintf("\n\tResults are written to '%s'\n", dataout->DataFilename().full());
if (type_ != EIGENVAL && type_ != RMSIP) {
if (bose_)
mprintf("\tBose statistics used.\n");
else
mprintf("\tBoltzmann statistics used.\n");
if (calcAll_)
mprintf("\tEigenvectors associated with zero or negative eigenvalues will be used.\n");
else
mprintf("\tEigenvectors associated with zero or negative eigenvalues will be skipped.\n");
}
if (type_ == DISPLACE)
mprintf("\tFactor for displacement: %f\n", factor_);
if (type_ == CORR) {
mprintf("\tUsing the following atom pairs:");
for (modestack_it apair = atompairStack_.begin();
apair != atompairStack_.end(); ++apair)
mprintf(" (%i,%i)", apair->first+1, apair->second+1 );
mprintf("\n");
}
if (type_ == RMSIP)
mprintf("\tRMSIP calculated to modes in %s\n", modinfo2_->legend());
} else {
mprintf("\n\tCreating trajectory for mode %i\n"
"\tWriting to trajectory %s\n"
"\tPC range: %f to %f\n"
"\tScaling factor: %f\n", tMode_,
trajout_.Traj().Filename().full(), pcmin_, pcmax_, factor_);
}
return Analysis::OK;
}
// DataIO_Std::WriteDataNormal()
int DataIO_Std::WriteDataNormal(CpptrajFile& file, DataSetList const& Sets) {
// Assume all 1D data sets.
if (Sets.empty() || CheckAllDims(Sets, 1)) return 1;
// For this output to work the X-dimension of all sets needs to match.
// The most important things for output are min and step so just check that.
// Use X dimension of set 0 for all set dimensions.
CheckXDimension( Sets );
// TODO: Check for empty dim.
DataSet* Xdata = Sets[0];
Dimension const& Xdim = static_cast<Dimension const&>( Xdata->Dim(0) );
int xcol_width = Xdim.Label().size() + 1; // Only used if hasXcolumn_
if (xcol_width < 8) xcol_width = 8;
int xcol_precision = 3;
// Determine size of largest DataSet.
size_t maxFrames = DetermineMax( Sets );
// Set up X column.
TextFormat x_col_format(XcolFmt());
if (hasXcolumn_) {
if (XcolPrecSet()) {
xcol_width = XcolWidth();
x_col_format = TextFormat(XcolFmt(), XcolWidth(), XcolPrec());
} else {
// Create format string for X column based on dimension in first data set.
// Adjust X col precision as follows: if the step is set and has a
// fractional component set the X col width/precision to either the data
// width/precision or the current width/precision, whichever is larger. If
// the set is XYMESH but step has not been set (so we do not know spacing
// between X values) use default precision. Otherwise the step has no
// fractional component so make the precision zero.
double step_i;
double step_f = modf( Xdim.Step(), &step_i );
double min_f = modf( Xdim.Min(), &step_i );
if (Xdim.Step() > 0.0 && (step_f > 0.0 || min_f > 0.0)) {
xcol_precision = std::max(xcol_precision, Xdata->Format().Precision());
xcol_width = std::max(xcol_width, Xdata->Format().Width());
} else if (Xdata->Type() != DataSet::XYMESH)
xcol_precision = 0;
x_col_format.SetCoordFormat( maxFrames, Xdim.Min(), Xdim.Step(), xcol_width, xcol_precision );
}
} else {
// If not writing an X-column, no leading space for the first dataset.
Xdata->SetupFormat().SetFormatAlign( TextFormat::RIGHT );
}
// Write header to buffer
std::vector<int> Original_Column_Widths;
if (writeHeader_) {
// If x-column present, write x-label
if (hasXcolumn_)
WriteNameToBuffer( file, Xdim.Label(), xcol_width, true );
// To prevent truncation of DataSet legends, adjust the width of each
// DataSet if necessary.
for (DataSetList::const_iterator ds = Sets.begin(); ds != Sets.end(); ++ds) {
// Record original column widths in case they are changed.
Original_Column_Widths.push_back( (*ds)->Format().Width() );
int colLabelSize;
if (ds == Sets.begin() && !hasXcolumn_)
colLabelSize = (int)(*ds)->Meta().Legend().size() + 1;
else
colLabelSize = (int)(*ds)->Meta().Legend().size();
//mprintf("DEBUG: Set '%s', fmt width= %i, colWidth= %i, colLabelSize= %i\n",
// (*ds)->legend(), (*ds)->Format().Width(), (*ds)->Format().ColumnWidth(),
// colLabelSize);
if (colLabelSize >= (*ds)->Format().ColumnWidth())
(*ds)->SetupFormat().SetFormatWidth( colLabelSize );
}
// Write dataset names to header, left-aligning first set if no X-column
DataSetList::const_iterator set = Sets.begin();
if (!hasXcolumn_)
WriteNameToBuffer( file, (*set)->Meta().Legend(), (*set)->Format().ColumnWidth(), true );
else
WriteNameToBuffer( file, (*set)->Meta().Legend(), (*set)->Format().ColumnWidth(), false );
++set;
for (; set != Sets.end(); ++set)
WriteNameToBuffer( file, (*set)->Meta().Legend(), (*set)->Format().ColumnWidth(), false );
file.Printf("\n");
}
// Write Data
DataSet::SizeArray positions(1);
for (positions[0] = 0; positions[0] < maxFrames; positions[0]++) {
// Output Frame for each set
if (hasXcolumn_)
file.Printf( x_col_format.fmt(), Xdata->Coord(0, positions[0]) );
for (DataSetList::const_iterator set = Sets.begin(); set != Sets.end(); ++set)
(*set)->WriteBuffer(file, positions);
file.Printf("\n");
}
// Restore original column widths if necessary
if (!Original_Column_Widths.empty())
for (unsigned int i = 0; i != Original_Column_Widths.size(); i++)
Sets[i]->SetupFormat().SetFormatWidth( Original_Column_Widths[i] );
return 0;
}
// DataIO_Std::WriteSet2D()
int DataIO_Std::WriteSet2D( DataSet const& setIn, CpptrajFile& file ) {
if (setIn.Ndim() != 2) {
mprinterr("Internal Error: DataSet %s in DataFile %s has %zu dimensions, expected 2.\n",
setIn.legend(), file.Filename().full(), setIn.Ndim());
return 1;
}
DataSet_2D const& set = static_cast<DataSet_2D const&>( setIn );
int xcol_width = 8;
int xcol_precision = 3;
Dimension const& Xdim = static_cast<Dimension const&>(set.Dim(0));
Dimension const& Ydim = static_cast<Dimension const&>(set.Dim(1));
if (Xdim.Step() == 1.0) xcol_precision = 0;
DataSet::SizeArray positions(2);
TextFormat ycoord_fmt(XcolFmt()), xcoord_fmt(XcolFmt());
if (square2d_) {
// Print XY values in a grid:
// x0y0 x1y0 x2y0
// x0y1 x1y1 x2y1
// x0y2 x1y2 x2y2
// If file has header, top-left value will be '#<Xlabel>-<Ylabel>',
// followed by X coordinate values.
if (writeHeader_) {
ycoord_fmt.SetCoordFormat( set.Nrows(), Ydim.Min(), Ydim.Step(), xcol_width, xcol_precision );
std::string header;
if (Xdim.Label().empty() && Ydim.Label().empty())
header = "#Frame";
else
header = "#" + Xdim.Label() + "-" + Ydim.Label();
WriteNameToBuffer( file, header, xcol_width, true );
xcoord_fmt.SetCoordFormat( set.Ncols(), Xdim.Min(), Xdim.Step(),
set.Format().ColumnWidth(), xcol_precision );
for (size_t ix = 0; ix < set.Ncols(); ix++)
file.Printf( xcoord_fmt.fmt(), set.Coord(0, ix) );
file.Printf("\n");
}
for (positions[1] = 0; positions[1] < set.Nrows(); positions[1]++) {
if (writeHeader_)
file.Printf( ycoord_fmt.fmt(), set.Coord(1, positions[1]) );
for (positions[0] = 0; positions[0] < set.Ncols(); positions[0]++)
set.WriteBuffer( file, positions );
file.Printf("\n");
}
} else {
// Print X Y Values
// x y val(x,y)
if (writeHeader_)
file.Printf("#%s %s %s\n", Xdim.Label().c_str(),
Ydim.Label().c_str(), set.legend());
if (XcolPrecSet()) {
xcoord_fmt = TextFormat(XcolFmt(), XcolWidth(), XcolPrec());
ycoord_fmt = xcoord_fmt;
} else {
xcoord_fmt.SetCoordFormat( set.Ncols(), Xdim.Min(), Xdim.Step(), 8, 3 );
ycoord_fmt.SetCoordFormat( set.Nrows(), Ydim.Min(), Ydim.Step(), 8, 3 );
}
std::string xy_fmt = xcoord_fmt.Fmt() + " " + ycoord_fmt.Fmt() + " ";
for (positions[1] = 0; positions[1] < set.Nrows(); ++positions[1]) {
for (positions[0] = 0; positions[0] < set.Ncols(); ++positions[0]) {
file.Printf( xy_fmt.c_str(), set.Coord(0, positions[0]), set.Coord(1, positions[1]) );
set.WriteBuffer( file, positions );
file.Printf("\n");
}
}
}
return 0;
}
