// Reads a rule in the file.
// (return "true" if the EOF is reached).
bool lpio::fReadRule(PosLogProg* plp, PosRule* rule) {
int cardBody; // number of rules in body+
int cardNegBody; // number of rules in body-
int atomNum; // atom number
MyAtom* atom; // pointer to the atom
int i;
if (fReadInt()==0) return true; // it is the end of rules declaration.
else {
// We read the rule's head :
atomNum = fReadInt();
atom = addAtom(atomNum, plp);
rule->setHead(atom);
atom->getHeadRules()->addRule(rule);
// We read the rule's bodies (Body+ and Body-) cardinalities :
cardBody=fReadInt();
cardNegBody=fReadInt();
// We read the rule negative body :
for (i=0;i<cardNegBody;i++){
atomNum = fReadInt();
atom = addAtom(atomNum, plp);
rule->addBodyMinus(atom);
}
// We read the rule positive body :
for (i=0;i<(cardBody-cardNegBody);i++){
atomNum = fReadInt();
atom = addAtom(atomNum, plp);
if (!rule->getBodyPlus()->contains(atom)){ // pb doublons dans body+
rule->addBodyPlus(atom);
atom->getPlusRules()->addRule(rule);
}
}
return false;
}
}
void HomeImpl::createHomeEntry(KIO::UDSEntry &entry,
const KUser &user)
{
kdDebug() << "HomeImpl::createHomeEntry" << endl;
entry.clear();
QString full_name = user.loginName();
if (!user.fullName().isEmpty())
{
full_name = user.fullName()+" ("+user.loginName()+")";
}
full_name = KIO::encodeFileName( full_name );
addAtom(entry, KIO::UDS_NAME, 0, full_name);
addAtom(entry, KIO::UDS_URL, 0, "home:/"+user.loginName());
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, "inode/directory");
QString icon_name = "folder_home2";
if (user.uid()==m_effectiveUid)
{
icon_name = "folder_home";
}
addAtom(entry, KIO::UDS_ICON_NAME, 0, icon_name);
KURL url;
url.setPath(user.homeDir());
entry += extractUrlInfos(url);
}
INLINE
void wxeReturn::addRef(const unsigned int ref, const char* className) {
addAtom("wx_ref");
addUint(ref);
addAtom(className);
rt.Add(ERL_DRV_NIL);
addTupleCount(4);
}
INLINE
void wxeReturn::addBool(int val) {
if (val) {
addAtom("true");
} else {
addAtom("false");
}
}
INLINE
void wxeReturn::add(const wxHtmlLinkInfo &val) {
addAtom("wxHtmlLinkInfo");
add(val.GetHref());
add(val.GetTarget());
addTupleCount(3);
}
void PeriodicAtomContainer::addAtoms(double * inPos, long nAtoms){
double * iPos;
for (long i = 0; i < nAtoms; i++){
iPos = inPos +i*DIM;
addAtom(iPos);
}
}
KIO::UDSEntry HomeImpl::extractUrlInfos(const KURL &url)
{
m_entryBuffer.clear();
KIO::StatJob *job = KIO::stat(url, false);
connect( job, SIGNAL( result(KIO::Job *) ),
this, SLOT( slotStatResult(KIO::Job *) ) );
qApp->eventLoop()->enterLoop();
KIO::UDSEntry::iterator it = m_entryBuffer.begin();
KIO::UDSEntry::iterator end = m_entryBuffer.end();
KIO::UDSEntry infos;
for(; it!=end; ++it)
{
switch( (*it).m_uds )
{
case KIO::UDS_ACCESS:
case KIO::UDS_USER:
case KIO::UDS_GROUP:
case KIO::UDS_CREATION_TIME:
case KIO::UDS_MODIFICATION_TIME:
case KIO::UDS_ACCESS_TIME:
infos.append(*it);
break;
default:
break;
}
}
addAtom(infos, KIO::UDS_LOCAL_PATH, 0, url.path());
return infos;
}
void AtomContainer::addAtom(const double * pos, const std::vector<std::string>& atomProperties){
int iProperty;
//after adding the atom was successful, continue with adding additional properties
if(addAtom(pos)) {
//save additional properties
for (iProperty = 0; iProperty < atomProperties.size(); iProperty++){
if (!atomPropertyList.isPropertyInt(iProperty)) {
//property has float type
atomPropertyList.addFloatPropertyValue(iProperty, atof(atomProperties[iProperty].c_str()));
} else {
//property has integer type
if (isFloat(atomProperties[iProperty])) {
//but current value is of float type -> conversion
atomPropertyList.convertPropertyToFloat(iProperty);
atomPropertyList.addFloatPropertyValue(iProperty, atof(atomProperties[iProperty].c_str()));
} else {
//value has also integer type -> add value
atomPropertyList.addIntPropertyValue(iProperty,atoi(atomProperties[iProperty].c_str()));
}
}
}
} else {
std::cout << "WARNING: Adding atom " << getNumAtoms() <<" failed (placed outside container)" << std::endl;
}
}
void RWMol::insertMol(const ROMol &other) {
std::vector<unsigned int> newAtomIds(other.getNumAtoms());
VERTEX_ITER firstA, lastA;
boost::tie(firstA, lastA) = boost::vertices(other.d_graph);
while (firstA != lastA) {
Atom *newAt = other.d_graph[*firstA]->copy();
unsigned int idx = addAtom(newAt, false, true);
newAtomIds[other.d_graph[*firstA]->getIdx()] = idx;
++firstA;
}
for (unsigned int ati = 0; ati < other.getNumAtoms(); ++ati) {
Atom *newAt = getAtomWithIdx(newAtomIds[ati]);
// take care of atom-numbering-dependent properties:
INT_VECT nAtoms;
if (newAt->getPropIfPresent(common_properties::_ringStereoAtoms, nAtoms)) {
BOOST_FOREACH (int &val, nAtoms) {
if (val < 0) {
val = -1 * (newAtomIds[(-val - 1)] + 1);
} else {
val = newAtomIds[val - 1] + 1;
}
}
newAt->setProp(common_properties::_ringStereoAtoms, nAtoms, true);
}
}
int Vocabulary::generatePredicateR(vector<int> _termsX, vector<int> _termsY) {
char name[32];
sprintf(name, "%s%d", R_PREFIX, m_nRPostfix ++);
int id = addSymbol(name, PREDICATE, _termsX.size() + _termsY.size());
_term* t = Utils::combineTerms(_termsX, _termsY);
addAtom(Formula(Utils::compositeToAtom(id, t), false));
return id;
}
void AtomContainer::addAtoms(double * inPos, long nAtoms){
double * iPos;
for (long i = 0; i < nAtoms; i++){
iPos = inPos + i*DIM ;
if(!addAtom(iPos)) {
std::cout << "WARNING: Adding atom " << i <<" failed (placed outside container)" << std::endl;
}
}
}
void Molecule::read(std::string file) {
InputFile fp(file);
std::vector<std::string> lines;
std::vector<std::string> pieces;
fp.readFile(lines);
std::string line, dat, units;
unsigned int pos, nrat;
double un;
/* grab basisset from first line 1 */
line = strtrim(lines[0]);
pos = strpos(line,"=");
dat = substr(line,pos+1);
basisset = strtrim(dat);
basis.setType(basisset);
//std::cout << basisset << std::endl;
/* grab charge from line 2 */
line = strtrim(lines[1]);
pos = strpos(line,"=");
dat = substr(line,pos+1);
charge = atoi(strtrim(dat).c_str() );
//std::cout << charge << std::endl;
/* grab number of atoms from line 3 */
line = strtrim(lines[2]);
pos = strpos(line,"=");
dat = substr(line,pos+1);
nrat = atoi(strtrim(dat).c_str() );
//std::cout << nrat << std::endl;
/* grab length unit from first line 4 */
line = strtrim(lines[3]);
pos = strpos(line,"=");
dat = substr(line,pos+1);
units = strtrim(dat);
if(units.compare("bohr")==0) {
un = 1;
}
if(units.compare("angstrom")==0) {
un = 1.0 / 0.52917721092;
}
//std::cout << units << std::endl;
double x, y, z;
std::string element;
for(unsigned int i=0; i<nrat; i++) {
line = strtrim(lines[4+i]);
pieces = explode(" ",line);
element = strtrim(pieces[0]);
x = atof(pieces[1].c_str() ) * un;
y = atof(pieces[2].c_str() ) * un;
z = atof(pieces[3].c_str() ) * un;
addAtom(element, x, y, z);
}
}
std::unique_ptr<RuntimeFile<ELFT>> MipsELFWriter<ELFT>::createRuntimeFile() {
auto file = llvm::make_unique<RuntimeFile<ELFT>>(_ctx, "Mips runtime file");
if (_ctx.isDynamic()) {
file->addAbsoluteAtom("_gp");
file->addAbsoluteAtom("_gp_disp");
file->addAbsoluteAtom("__gnu_local_gp");
file->addAtom(*new (file->allocator()) MipsDynamicAtom(*file));
}
return file;
}
/// Adds a new atom to the molecule. The new atom will have the same
/// properties as atom (atomic number, mass number, etc).
Atom* Molecule::addAtomCopy(const Atom *atom)
{
Atom *newAtom = addAtom(atom->atomicNumber());
newAtom->setMassNumber(atom->massNumber());
newAtom->setPartialCharge(atom->partialCharge());
newAtom->setPosition(atom->position());
newAtom->setChirality(atom->chirality());
return newAtom;
}
wxeReturn::wxeReturn (ErlDrvPort _port,
ErlDrvTermData _caller,
bool _isResult) {
port = _port;
caller = _caller;
isResult = _isResult;
if (isResult) {
addAtom("_wxe_result_");
}
}
void HomeImpl::createTopLevelEntry(KIO::UDSEntry &entry) const
{
entry.clear();
addAtom(entry, KIO::UDS_NAME, 0, ".");
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_ACCESS, 0555);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, "inode/directory");
addAtom(entry, KIO::UDS_ICON_NAME, 0, "kfm_home");
addAtom(entry, KIO::UDS_USER, 0, "root");
addAtom(entry, KIO::UDS_GROUP, 0, "root");
}
void KMobileDevice::createFileEntry(KIO::UDSEntry& entry, const QString& name, const QString& url, const QString& mime,
const unsigned long size) const
{
entry.clear();
addAtom(entry, KIO::UDS_NAME, 0, name);
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFREG);
addAtom(entry, KIO::UDS_URL, 0, url);
addAtom(entry, KIO::UDS_ACCESS, 0400);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, mime);
if (size) addAtom(entry, KIO::UDS_SIZE, size);
addAtom(entry, KIO::UDS_GUESSED_MIME_TYPE, 0, mime);
PRINT_DEBUG << QString("createFileEntry: File: %1, Size: %2, MIME: %3\n").arg(name).arg(size).arg(mime);
}
void TrashProtocol::createTopLevelDirEntry(KIO::UDSEntry &entry)
{
entry.clear();
addAtom(entry, KIO::UDS_NAME, 0, ".");
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_ACCESS, 0700);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, "inode/directory");
addAtom(entry, KIO::UDS_USER, 0, m_userName);
addAtom(entry, KIO::UDS_GROUP, 0, m_groupName);
}
void MediaImpl::createTopLevelEntry(KIO::UDSEntry &entry) const
{
entry.clear();
addAtom(entry, KIO::UDS_URL, 0, "media:/");
addAtom(entry, KIO::UDS_NAME, 0, ".");
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_ACCESS, 0555);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, "inode/directory");
addAtom(entry, KIO::UDS_ICON_NAME, 0, "blockdevice");
}
ZMatrixDialog::ZMatrixDialog(QWidget *parent, Qt::WindowFlags) :
QDialog(parent), m_zMatrixModel(new ZMatrixModel), m_molecule(0)
{
setWindowFlags(Qt::Dialog | Qt::Tool);
ui.setupUi(this);
ui.tableView->setModel(m_zMatrixModel);
QHeaderView *horizontal = ui.tableView->horizontalHeader();
horizontal->setResizeMode(QHeaderView::Stretch);
QHeaderView *vertical = ui.tableView->verticalHeader();
vertical->setResizeMode(QHeaderView::Stretch);
// Connect our signals and slots...
connect(ui.addButton, SIGNAL(clicked()), this, SLOT(addAtom()));
connect(ui.removeButton, SIGNAL(clicked()), this, SLOT(removeAtom()));
}
// Reads the positive (resp. negative) part of the compute statement
void lpio::fReadComputeStat(PosLogProg* plp, PosRule* rule){
char str[NAME_LGTH];
bool positive;
int atomNum;
MyAtom* atom;
fReadStr(str);
positive = (strcmp(str,"B+")==0);
do {
atomNum=fReadInt();
if (atomNum!=0){
atom = addAtom(atomNum, plp);
if (positive) rule->addBodyPlus(atom);
else rule->addBodyMinus(atom);
}
} while (atomNum!=0);
}
INLINE
void wxeReturn::add(wxMouseState val) {
addAtom("wxMouseState");
// TODO not int?
addUint(val.GetX());
addUint(val.GetY());
addBool(val.LeftDown());
addBool(val.MiddleDown());
addBool(val.RightDown());
addBool(val.ControlDown());
addBool(val.ShiftDown());
addBool(val.AltDown());
addBool(val.MetaDown());
addBool(val.CmdDown());
addTupleCount(11);
}
void KMobileDevice::createDirEntry(KIO::UDSEntry& entry, const QString& name, const QString& url, const QString& mime) const
{
entry.clear();
addAtom(entry, KIO::UDS_NAME, 0, name);
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_ACCESS, 0500);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, mime);
addAtom(entry, KIO::UDS_URL, 0, url);
PRINT_DEBUG << QString("createDirEntry: File: %1 MIME: %2 URL: %3\n").arg(name).arg(mime).arg(url);
// addAtom(entry, KIO::UDS_SIZE, 0);
addAtom(entry, KIO::UDS_GUESSED_MIME_TYPE, 0, mime);
}
void MediaImpl::createMediumEntry(KIO::UDSEntry &entry, const Medium &medium)
{
kdDebug(1219) << "MediaProtocol::createMedium" << endl;
QString url = "media:/" + medium.name();
kdDebug(1219) << "url = " << url << ", mime = " << medium.mimeType() << endl;
entry.clear();
addAtom(entry, KIO::UDS_URL, 0, url);
QString label = KIO::encodeFileName(medium.prettyLabel());
addAtom(entry, KIO::UDS_NAME, 0, label);
addAtom(entry, KIO::UDS_FILE_TYPE, S_IFDIR);
addAtom(entry, KIO::UDS_MIME_TYPE, 0, medium.mimeType());
addAtom(entry, KIO::UDS_GUESSED_MIME_TYPE, 0, "inode/directory");
if(!medium.iconName().isEmpty())
{
addAtom(entry, KIO::UDS_ICON_NAME, 0, medium.iconName());
}
else
{
QString mime = medium.mimeType();
QString icon = KMimeType::mimeType(mime)->icon(mime, false);
addAtom(entry, KIO::UDS_ICON_NAME, 0, icon);
}
if(medium.needMounting())
{
addAtom(entry, KIO::UDS_ACCESS, 0400);
}
else
{
KURL url = medium.prettyBaseURL();
entry += extractUrlInfos(url);
}
}
void AtomsBuilder::mergeAtoms(const t_atoms &atoms)
{
if (atoms_->nr + atoms.nr > nrAlloc_
|| atoms_->nres + atoms.nres > nresAlloc_)
{
reserve(atoms_->nr + atoms.nr, atoms_->nres + atoms.nres);
}
int prevResInd = -1;
for (int i = 0; i < atoms.nr; ++i)
{
const int resind = atoms.atom[i].resind;
if (resind != prevResInd)
{
startResidue(atoms.resinfo[resind]);
prevResInd = resind;
}
addAtom(atoms, i);
}
}
// Reads the atoms names and return the atoms number :
int lpio::fReadAtoms(PosLogProg* plp){
int idAtom,atomsNb=0, i=1;
char str[NAME_LGTH];
idAtom=fReadInt();
while (idAtom!=0){
if (idAtom != i){ // there are "anonymous" atoms
MyAtom* atom = addAtom(i, plp);
atom->setName("_false_");
}
else {
atomsNb=idAtom;
fReadStr(str);
plp->getAtom(idAtom)->setName(str);
idAtom=fReadInt();
}
i++;
};
return atomsNb;
}
// Broadcast data from Master to all Slaves
bool GrainDefinition::broadcast(const List<Atom>& atoms)
{
#ifdef PARALLEL
int n, count, index;
// Name
if (!procPool.broadcast(name_)) return false;
// Atoms
count = atoms_.nItems();
if (!procPool.broadcast(&count, 1)) return false;
for (n=0; n<count; ++n)
{
if (Comm.master()) index = atoms_.item(n)->item->index();
if (!procPool.broadcast(&index, 1)) return false;
if (Comm.slave()) addAtom(atoms.item(index));
}
#endif
return true;
}
// Load Species information from XYZ file
bool Species::loadFromXYZ(const char* filename)
{
Messenger::print("Loading XYZ data from file '%s'\n", filename);
// Open the specified file...
LineParser parser;
parser.openInput(filename);
if (!parser.isFileGoodForReading())
{
Messenger::error("Couldn't open XYZ file '%s'.\n", filename);
return false;
}
// Clear any existing data
clear();
// Simple format - first line is number of atoms, next line is title, then follow atoms/coordinates, one atom per line
parser.getArgsDelim(LineParser::Defaults);
int nAtoms = parser.argi(0);
parser.readNextLine(LineParser::Defaults);
name_ = parser.line();
int el, success;
for (int n=0; n<nAtoms; ++n)
{
success = parser.getArgsDelim(LineParser::Defaults);
if (success != 0)
{
parser.closeFiles();
Messenger::error("Couldn't read Atom %i from file '%s'\n", n+1, filename);
return false;
}
el = PeriodicTable::find(parser.argc(0));
if (el == -1) el = 0;
SpeciesAtom* i = addAtom(el, parser.argd(1), parser.argd(2),parser.argd(3));
if (parser.hasArg(4)) i->setCharge(parser.argd(4));
}
Messenger::print("Succesfully loaded XYZ data from file '%s'.\n", filename);
parser.closeFiles();
return true;
}
KIO::UDSEntry MediaImpl::extractUrlInfos(const KURL &url)
{
m_entryBuffer.clear();
KIO::StatJob *job = KIO::stat(url, false);
job->setAutoWarningHandlingEnabled(false);
connect(job, SIGNAL(result(KIO::Job *)), this, SLOT(slotStatResult(KIO::Job *)));
connect(job, SIGNAL(warning(KIO::Job *, const QString &)), this, SLOT(slotWarning(KIO::Job *, const QString &)));
qApp->eventLoop()->enterLoop();
KIO::UDSEntry::iterator it = m_entryBuffer.begin();
KIO::UDSEntry::iterator end = m_entryBuffer.end();
KIO::UDSEntry infos;
for(; it != end; ++it)
{
switch((*it).m_uds)
{
case KIO::UDS_ACCESS:
case KIO::UDS_USER:
case KIO::UDS_GROUP:
case KIO::UDS_CREATION_TIME:
case KIO::UDS_MODIFICATION_TIME:
case KIO::UDS_ACCESS_TIME:
infos.append(*it);
break;
default:
break;
}
}
if(url.isLocalFile())
{
addAtom(infos, KIO::UDS_LOCAL_PATH, 0, url.path());
}
return infos;
}
void Molecule::addHydrogens(Atom *a,
const QList<unsigned long> &atomIds,
const QList<unsigned long> &bondIds)
{
if (atomIds.size() != bondIds.size()) {
qDebug() << "Error, addHydrogens called with atom & bond id lists of different size!";
}
// Construct an OBMol, call AddHydrogens and translate the changes
OpenBabel::OBMol obmol = OBMol();
if (a) {
OpenBabel::OBAtom *obatom = obmol.GetAtom(a->index()+1);
// Set implicit valence for unusual elements not handled by OpenBabel
// PR#2803076
switch (obatom->GetAtomicNum()) {
case 3:
case 11:
case 19:
case 37:
case 55:
case 85:
case 87:
obatom->SetImplicitValence(1);
obatom->SetHyb(1);
obmol.SetImplicitValencePerceived();
break;
case 4:
case 12:
case 20:
case 38:
case 56:
case 88:
obatom->SetImplicitValence(2);
obatom->SetHyb(2);
obmol.SetImplicitValencePerceived();
break;
case 84: // Po
obatom->SetImplicitValence(2);
obatom->SetHyb(3);
obmol.SetImplicitValencePerceived();
break;
default: // do nothing
break;
}
obmol.AddHydrogens(obatom);
}
else
obmol.AddHydrogens();
// All new atoms in the OBMol must be the additional hydrogens
unsigned int numberAtoms = numAtoms();
int j = 0;
for (unsigned int i = numberAtoms+1; i <= obmol.NumAtoms(); ++i, ++j) {
if (obmol.GetAtom(i)->IsHydrogen()) {
OpenBabel::OBAtom *obatom = obmol.GetAtom(i);
Atom *atom;
if (atomIds.isEmpty())
atom = addAtom();
else if (j < atomIds.size())
atom = addAtom(atomIds.at(j));
else {
qDebug() << "Error - not enough unique ids in addHydrogens.";
break;
}
atom->setOBAtom(obatom);
// Get the neighbor atom
OpenBabel::OBBondIterator iter;
OpenBabel::OBAtom *next = obatom->BeginNbrAtom(iter);
Bond *bond;
if (bondIds.isEmpty())
bond = addBond();
else // Already confirmed by atom ids
bond = addBond(bondIds.at(j));
bond->setEnd(Molecule::atom(atom->index()));
bond->setBegin(Molecule::atom(next->GetIdx()-1));
}
}
for (unsigned int i = 1; i <= numberAtoms; ++i) {
// Warning -- OB atom index off-by-one here
atom(i-1)->setPartialCharge(obmol.GetAtom(i)->GetPartialCharge());
}
}
