void XbelReader::readFolder(QTreeWidgetItem *item)
{
Q_ASSERT(isStartElement() && name() == "folder");
QTreeWidgetItem *folder = createChildItem(item);
bool folded = (attributes().value("folded") != "no");
treeWidget->setItemExpanded(folder, !folded);
while (!atEnd()) {
readNext();
if (isEndElement())
break;
if (isStartElement()) {
if (name() == "title")
readTitle(folder);
else if (name() == "folder")
readFolder(folder);
else if (name() == "bookmark")
readBookmark(folder);
else if (name() == "separator")
readSeparator(folder);
else
readUnknownElement();
}
}
}
void XbelReader::readFolder(BookmarkNode *parent)
{
Q_ASSERT(isStartElement() && name() == QLatin1String("folder"));
BookmarkNode *folder = new BookmarkNode(BookmarkNode::Folder, parent);
folder->expanded = (attributes().value(QLatin1String("folded")) == QLatin1String("no"));
while (!atEnd()) {
readNext();
if (isEndElement())
break;
if (isStartElement()) {
if (name() == QLatin1String("title"))
readTitle(folder);
else if (name() == QLatin1String("desc"))
readDescription(folder);
else if (name() == QLatin1String("folder"))
readFolder(folder);
else if (name() == QLatin1String("bookmark"))
readBookmarkNode(folder);
else if (name() == QLatin1String("separator"))
readSeparator(folder);
else
skipUnknownElement();
}
}
}
void FileReader::parseDocument(const QDomElement& element) {
model->removeRows(0, model->rowCount());
int row=0;
QDomNode child = element.firstChild();
while(!child.isNull()) {
if(child.toElement().tagName() == "title")
readTitle(child.toElement());
else if(child.toElement().tagName() == "xlabel")
readXLabel(child.toElement());
else if(child.toElement().tagName() == "ylabel")
readYLabel(child.toElement());
else if(child.toElement().tagName() == "point") {
model->insertRow(row);
QDomNode nephew = child.firstChild();
while(!nephew.isNull()) {
if(nephew.toElement().tagName() == "x")
model->setData(model->index(row, 0), nephew.toElement().text());
else if(nephew.toElement().tagName() == "y")
model->setData(model->index(row, 1), nephew.toElement().text());
nephew = nephew.nextSibling();
}
row++;
}
child = child.nextSibling();
}
}
void XbelReader::readBookmarkNode(BookmarkNode *parent)
{
Q_ASSERT(isStartElement() && name() == QLatin1String("bookmark"));
BookmarkNode *bookmark = new BookmarkNode(BookmarkNode::Bookmark, parent);
bookmark->url = attributes().value(QLatin1String("href")).toString();
while (readNextStartElement()) {
if (name() == QLatin1String("title"))
readTitle(bookmark);
else if (name() == QLatin1String("desc"))
readDescription(bookmark);
else
skipCurrentElement();
}
if (bookmark->title.isEmpty())
bookmark->title = QObject::tr("Unknown title");
}
void XbelReader::readBookmark(QTreeWidgetItem *item)
{
Q_ASSERT(xml.isStartElement() && xml.name() == "bookmark");
QTreeWidgetItem *bookmark = createChildItem(item);
bookmark->setFlags(bookmark->flags() | Qt::ItemIsEditable);
bookmark->setIcon(0, bookmarkIcon);
bookmark->setText(0, QObject::tr("Unknown title"));
bookmark->setText(1, xml.attributes().value("href").toString());
while (xml.readNextStartElement()) {
if (xml.name() == "title")
readTitle(bookmark);
else
xml.skipCurrentElement();
}
}
void XbelReader::readFolder(QTreeWidgetItem *item)
{
Q_ASSERT(xml.isStartElement() && xml.name() == "folder");
QTreeWidgetItem *folder = createChildItem(item);
bool folded = (xml.attributes().value("folded") != "no");
treeWidget->setItemExpanded(folder, !folded);
while (xml.readNextStartElement()) {
if (xml.name() == "title")
readTitle(folder);
else if (xml.name() == "folder")
readFolder(folder);
else if (xml.name() == "bookmark")
readBookmark(folder);
else if (xml.name() == "separator")
readSeparator(folder);
else
xml.skipCurrentElement();
}
}
void XbelReader::readBookmark(QTreeWidgetItem *item)
{
Q_ASSERT(isStartElement() && name() == "bookmark");
QTreeWidgetItem *bookmark = createChildItem(item);
bookmark->setFlags(bookmark->flags() | Qt::ItemIsEditable);
bookmark->setIcon(0, bookmarkIcon);
bookmark->setText(0, QObject::tr("Unknown title"));
bookmark->setText(1, attributes().value("href").toString());
while (!atEnd()) {
readNext();
if (isEndElement())
break;
if (isStartElement()) {
if (name() == "title")
readTitle(bookmark);
else
readUnknownElement();
}
}
}
int parseLine(int sect, char *line)
//
// Input: sect = current section of input file
// *line = line of text read from input file
// Output: returns error code or 0 if no error found
// Purpose: parses contents of a tokenized line of text read from input file.
//
{
int j, err;
switch (sect)
{
case s_TITLE:
return readTitle(line);
case s_RAINGAGE:
j = Mobjects[GAGE];
err = gage_readParams(j, Tok, Ntokens);
Mobjects[GAGE]++;
return err;
case s_TEMP:
return climate_readParams(Tok, Ntokens);
case s_EVAP:
return climate_readEvapParams(Tok, Ntokens);
case s_ADJUST: //(5.1.007)
return climate_readAdjustments(Tok, Ntokens); //(5.1.007)
case s_SUBCATCH:
j = Mobjects[SUBCATCH];
err = subcatch_readParams(j, Tok, Ntokens);
Mobjects[SUBCATCH]++;
return err;
case s_SUBAREA:
return subcatch_readSubareaParams(Tok, Ntokens);
case s_INFIL:
return infil_readParams(InfilModel, Tok, Ntokens);
case s_AQUIFER:
j = Mobjects[AQUIFER];
err = gwater_readAquiferParams(j, Tok, Ntokens);
Mobjects[AQUIFER]++;
return err;
case s_GROUNDWATER:
return gwater_readGroundwaterParams(Tok, Ntokens);
case s_GWF:
return gwater_readFlowExpression(Tok, Ntokens);
case s_SNOWMELT:
return snow_readMeltParams(Tok, Ntokens);
case s_JUNCTION:
return readNode(JUNCTION);
case s_OUTFALL:
return readNode(OUTFALL);
case s_STORAGE:
return readNode(STORAGE);
case s_DIVIDER:
return readNode(DIVIDER);
case s_CONDUIT:
return readLink(CONDUIT);
case s_PUMP:
return readLink(PUMP);
case s_ORIFICE:
return readLink(ORIFICE);
case s_WEIR:
return readLink(WEIR);
case s_OUTLET:
return readLink(OUTLET);
case s_XSECTION:
return link_readXsectParams(Tok, Ntokens);
case s_TRANSECT:
return transect_readParams(&Mobjects[TRANSECT], Tok, Ntokens);
case s_LOSSES:
return link_readLossParams(Tok, Ntokens);
case s_POLLUTANT:
j = Mobjects[POLLUT];
err = landuse_readPollutParams(j, Tok, Ntokens);
Mobjects[POLLUT]++;
return err;
case s_LANDUSE:
j = Mobjects[LANDUSE];
err = landuse_readParams(j, Tok, Ntokens);
Mobjects[LANDUSE]++;
return err;
case s_BUILDUP:
return landuse_readBuildupParams(Tok, Ntokens);
case s_WASHOFF:
return landuse_readWashoffParams(Tok, Ntokens);
case s_COVERAGE:
return subcatch_readLanduseParams(Tok, Ntokens);
case s_INFLOW:
return inflow_readExtInflow(Tok, Ntokens);
case s_DWF:
return inflow_readDwfInflow(Tok, Ntokens);
case s_PATTERN:
return inflow_readDwfPattern(Tok, Ntokens);
case s_RDII:
return rdii_readRdiiInflow(Tok, Ntokens);
case s_UNITHYD:
return rdii_readUnitHydParams(Tok, Ntokens);
case s_LOADING:
return subcatch_readInitBuildup(Tok, Ntokens);
case s_TREATMENT:
return treatmnt_readExpression(Tok, Ntokens);
case s_CURVE:
return table_readCurve(Tok, Ntokens);
case s_TIMESERIES:
return table_readTimeseries(Tok, Ntokens);
case s_CONTROL:
return readControl(Tok, Ntokens);
case s_REPORT:
return report_readOptions(Tok, Ntokens);
case s_FILE:
return iface_readFileParams(Tok, Ntokens);
case s_LID_CONTROL:
return lid_readProcParams(Tok, Ntokens);
case s_LID_USAGE:
return lid_readGroupParams(Tok, Ntokens);
default: return 0;
}
}
bool POSFormat::ReadMolecule(OBBase* pOb, OBConversion* pConv)
{
OBMol* pmol = pOb->CastAndClear<OBMol>();
if(pmol==NULL)
return false;
//Define some references so we can use the old parameter names
istream &ifs = *pConv->GetInStream();
OBMol &mol = *pmol;
const char* defaultTitle = pConv->GetTitle();
char buffer[BUFF_SIZE];
stringstream errorMsg;
unsigned int natoms;
if (!ifs)
return false; // we're attempting to read past the end of the file
if (!ifs.getline(buffer,BUFF_SIZE))
{
obErrorLog.ThrowError(__FUNCTION__,
"Problems reading an XYZ file: Cannot read the first line.", obWarning);
return(false);
}
if (sscanf(buffer, "%d", &natoms) == 0 || !natoms)
{
obErrorLog.ThrowError(__FUNCTION__,
"Problems reading an XYZ file: The first line must contain the number of atoms.", obWarning);
return(false);
}
mol.ReserveAtoms(natoms);
// The next line contains a title string for the molecule. Use this
// as the title for the molecule if the line is not
// empty. Otherwise, use the title given by the calling function.
if (!ifs.getline(buffer,BUFF_SIZE))
{
obErrorLog.ThrowError(__FUNCTION__,
"Problems reading an XYZ file: Could not read the second line (title/comments).", obWarning);
return(false);
}
string readTitle(buffer);
Trim(readTitle);
// This should give the location of the spacegroup number
string::size_type location = readTitle.find("#");
int spaceGroup = -1;
if (location != string::npos) {
// e.g., "#230"
string spaceGroupNumber = readTitle.substr(location + 1, 4); // +1 to skip #
string::size_type nonNumber = spaceGroupNumber.find_first_not_of("0123456789");
if (nonNumber != string::npos)
spaceGroupNumber.erase(nonNumber);
// Finally get the space group from the file
spaceGroup = atoi(spaceGroupNumber.c_str());
}
location = readTitle.find_first_not_of(" \t\n\r");
// Is there non-whitespace
if (location != string::npos)
mol.SetTitle(readTitle);
else
mol.SetTitle(defaultTitle);
vector3 v1, v2, v3;
double x,y,z;
vector<string> vs;
OBAtom *atom;
int atomicNum;
bool setCellVectors = false;
// go through remaining lines, particularly looking for cell vectors
mol.BeginModify();
while(ifs.peek() != EOF && ifs.good()) {
ifs.getline(buffer,BUFF_SIZE);
if (strstr(buffer, "Primitive vectors")) {
// three lines: a(#) = .. .. ..
ifs.getline(buffer, BUFF_SIZE);
tokenize(vs,buffer);
if (vs.size() != 5)
continue;
v1.SetX(atof(vs[2].c_str()));
v1.SetY(atof(vs[3].c_str()));
v1.SetZ(atof(vs[4].c_str()));
ifs.getline(buffer, BUFF_SIZE);
tokenize(vs,buffer);
if (vs.size() != 5)
continue;
v2.SetX(atof(vs[2].c_str()));
v2.SetY(atof(vs[3].c_str()));
v2.SetZ(atof(vs[4].c_str()));
ifs.getline(buffer, BUFF_SIZE);
tokenize(vs,buffer);
if (vs.size() != 5)
continue;
v3.SetX(atof(vs[2].c_str()));
v3.SetY(atof(vs[3].c_str()));
v3.SetZ(atof(vs[4].c_str()));
setCellVectors = true;
}
if (strstr(buffer, "Basis Vectors:")) {
ifs.getline(buffer,BUFF_SIZE); // column titles
ifs.getline(buffer,BUFF_SIZE); // blank
// real atomic data
while (ifs.getline(buffer,BUFF_SIZE) && strlen(buffer)) {
tokenize(vs,buffer);
if (vs.size() != 7)
break;
atom = mol.NewAtom();
// check to see if first column is number or element symbol
// (PCModel has files of the form X Y Z symbol)
atomicNum = OBElements::GetAtomicNum(vs[0].c_str());
x = atof(vs[4].c_str());
y = atof(vs[5].c_str());
z = atof(vs[6].c_str());
atom->SetVector(x,y,z);
atom->SetAtomicNum(atomicNum);
}
}
}
if (setCellVectors) {
OBUnitCell* uc = new OBUnitCell;
uc->SetData(v1, v2, v3);
uc->SetOrigin(fileformatInput);
mol.SetData(uc);
// hopefully, we have a space group too
if (spaceGroup != -1) {
uc->SetSpaceGroup(spaceGroup);
}
}
if (!pConv->IsOption("b",OBConversion::INOPTIONS))
mol.ConnectTheDots();
if (!pConv->IsOption("s",OBConversion::INOPTIONS) && !pConv->IsOption("b",OBConversion::INOPTIONS))
mol.PerceiveBondOrders();
mol.EndModify();
return(true);
}
/** Executes the algorithm. Reading in the file and creating and populating
* the output workspace
*
* @throw Exception::FileError If the RAW file cannot be found/opened
* @throw std::invalid_argument If the optional properties are set to invalid values
*/
void LoadRawBin0::exec()
{
// Retrieve the filename from the properties
m_filename = getPropertyValue("Filename");
bool bLoadlogFiles = getProperty("LoadLogFiles");
//open the raw file
FILE* file=openRawFile(m_filename);
// Need to check that the file is not a text file as the ISISRAW routines don't deal with these very well, i.e
// reading continues until a bad_alloc is encountered.
if( isAscii(file) )
{
g_log.error() << "File \"" << m_filename << "\" is not a valid RAW file.\n";
throw std::invalid_argument("Incorrect file type encountered.");
}
std::string title;
readTitle(file,title);
readworkspaceParameters(m_numberOfSpectra,m_numberOfPeriods,m_lengthIn,m_noTimeRegimes);
///
setOptionalProperties();
// to validate the optional parameters, if set
checkOptionalProperties();
// Calculate the size of a workspace, given its number of periods & spectra to read
m_total_specs = calculateWorkspaceSize();
//no real X values for bin 0,so initialize this to zero
boost::shared_ptr<MantidVec> channelsVec(new MantidVec(1,0));
m_timeChannelsVec.push_back(channelsVec);
double histTotal = static_cast<double>(m_total_specs * m_numberOfPeriods);
int64_t histCurrent = -1;
// Create the 2D workspace for the output xlength and ylength is one
DataObjects::Workspace2D_sptr localWorkspace = createWorkspace(m_total_specs, 1,1,title);
Run& run = localWorkspace->mutableRun();
if (bLoadlogFiles)
{
runLoadLog(m_filename,localWorkspace, 0.0, 0.0);
const int period_number = 1;
createPeriodLogs(period_number, localWorkspace);
}
// Set the total proton charge for this run
setProtonCharge(run);
WorkspaceGroup_sptr ws_grp = createGroupWorkspace();
setWorkspaceProperty("OutputWorkspace", title, ws_grp, localWorkspace,m_numberOfPeriods, false);
// Loop over the number of periods in the raw file, putting each period in a separate workspace
for (int period = 0; period < m_numberOfPeriods; ++period)
{
if (period > 0)
{
localWorkspace=createWorkspace(localWorkspace);
if (bLoadlogFiles)
{
//remove previous period data
std::stringstream prevPeriod;
prevPeriod << "PERIOD " << (period);
Run& runObj = localWorkspace->mutableRun();
runObj.removeLogData(prevPeriod.str());
runObj.removeLogData("current_period");
//add current period data
const int period_number = period + 1;
createPeriodLogs(period_number, localWorkspace);
}
}
skipData(file, period * (m_numberOfSpectra + 1));
int64_t wsIndex = 0;
for (specid_t i = 1; i <= m_numberOfSpectra; ++i)
{
int64_t histToRead = i + period * (m_numberOfSpectra + 1);
if ((i >= m_spec_min && i < m_spec_max) || (m_list && find(m_spec_list.begin(), m_spec_list.end(),
i) != m_spec_list.end()))
{
progress(m_prog, "Reading raw file data...");
//readData(file, histToRead);
//read spectrum
if (!readData(file, histToRead))
{
throw std::runtime_error("Error reading raw file");
}
int64_t binStart=0;
setWorkspaceData(localWorkspace, m_timeChannelsVec, wsIndex, i, m_noTimeRegimes,1,binStart);
++wsIndex;
if (m_numberOfPeriods == 1)
{
if (++histCurrent % 100 == 0)
{
m_prog = double(histCurrent) / histTotal;
}
interruption_point();
}
}
else
{
skipData(file, histToRead);
}
}
if(m_numberOfPeriods>1)
{
setWorkspaceProperty(localWorkspace, ws_grp, period, false);
// progress for workspace groups
m_prog = static_cast<double>(period) / static_cast<double>(m_numberOfPeriods - 1);
}
} // loop over periods
// Clean up
isisRaw.reset();
fclose(file);
}
