ion.cpp

Go to the documentation of this file.

/* ion.h : atomic and molecular ion primitive
 * Copyright (C) 2014  Daniel Haley
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "atomprobe/helper/stringFuncs.h"
#include "atomprobe/primitives/ion.h"
#include "atomprobe/helper/misc.h"

#include <set>
#include <map>
#include <cctype>
#include <vector>
#include <cstring>
#include <utility>
#include <fstream>

using std::string;
using std::vector;
using std::pair;
using std::make_pair;
using std::string;

namespace AtomProbe{

Ion::Ion(const std::string &strName) {
    std::vector<std::pair<std::string,size_t> > ionFragments;
    ionStr2ionFragments(strName, ionFragments);
    setIonFragments(ionFragments);
}

Ion::Ion(const std::string &strName, const unsigned int chargeState) {
    std::vector<std::pair<std::string,size_t> > ionFragments;
    ionStr2ionFragments(strName, ionFragments);
    setIonFragments(ionFragments);
    setChargeState(chargeState);
}

bool Ion::ionStr2ionFragments(const std::string &name,
                        std::vector<pair<string,size_t> > &fragments)
{
    // Take a string and turn it into an ion class
    // str could have charge state (+ char) or not
    // Parse text and turn it into elemental fragments
    size_t lastMarker=0;
    size_t digitMarker=0;

    if(!name.size())
        return true;

    //Atomic naming systems use uppercase ascii
    // letters, like "A" in Au, or Ag as delimiters.
    //
    // numerals are multipliers, and are forbidden
    // for the first char...
    if(!isalnum(name[0]) ||
            isdigit(name[0]) || islower(name[0]))
        return false;

    //true - was last, or now am on ion name
    //false - am still on multiplier
    bool nameMode=true;
    for(size_t ui=1;ui<name.size();ui++)
    {
        if(!isalnum(name[ui]))
            return false;

        if(nameMode)
        {
            //If we hit a digit,
            //this means that we
            //are now on a multiplier
            if(isdigit(name[ui]))
            {
                digitMarker=ui;
                nameMode=false;
                continue;
            }

            if(isupper(name[ui]))
            {
                //Looks like we hit another
                // ion name, without hitting any
                // specification for the number.
                // This means unitary spec.
                std::string s;
                s=name.substr(lastMarker,ui-lastMarker);
                fragments.push_back(make_pair(s,1));
                lastMarker=ui;
            }
        }
        else
        {
            //OK, we still have a digit.
            // keep moving
            if(isdigit(name[ui]))
                continue;

            if(isalpha(name[ui]))
            {
                //OK, this looks like a new ion
                //but we need to record multiplicity
                std::string s,sDigit;
                s=name.substr(lastMarker,digitMarker-lastMarker);

                sDigit=name.substr(digitMarker,ui-digitMarker);

                size_t multiplicity;
                stream_cast(multiplicity,sDigit);

                fragments.push_back(make_pair(s,multiplicity));

                lastMarker=ui;
                nameMode=true;
            }

        }
    }

    if(nameMode)
    {
        //Hit end of string.
        //record fragment
        std::string s;
        s=name.substr(lastMarker,name.size()-lastMarker);
        fragments.push_back(make_pair(s,1));
    }
    else
    {
        std::string s,sDigit;
        s=name.substr(lastMarker,digitMarker-lastMarker);
        sDigit=name.substr(digitMarker,name.size()-digitMarker);

        size_t multiplicity;
        stream_cast(multiplicity,sDigit);

        fragments.push_back(make_pair(s,multiplicity));
    }


    //Spin through dataset and collect the non-unique fragment
    vector<bool> toKill(fragments.size(),false);
    for(size_t ui=0;ui<fragments.size();ui++)
    {
        //skip empty fragments
        if(fragments[ui].first.empty())
            continue;

        for(size_t uj=ui+1;uj<fragments.size();uj++)
        {
            //skip empty fragments
            if(fragments[uj].first.empty())
                continue;

            //Collect fragment multiplicities if they have the same name
            if(fragments[uj].first == fragments[ui].first)
            {
                fragments[ui].second+=fragments[uj].second;
                fragments[uj].first=""; //Zero out name so we don't hit it

                toKill[uj]=true;

            }
        }
    }

    vectorMultiErase(fragments,toKill);

    return true;
}

bool Ion::ionFragments2ionStr(const std::vector<pair<string,size_t> > &fragments,
                              std::string &name)
{
    for (auto frag:fragments){
    if ((frag).second == 1) {
        name += (frag).first; // element name only
    } else {
        // name and how many of the element there are
        name += (frag).first + std::to_string((frag).second);
    }
    }
    return true;
}

} // namespace AtomProbe