multiRange.h

Go to the documentation of this file.

/*
 * multiRange.h - Atom probe rangefile class 
 * Copyright (C) 2014  D 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/>.
 */

#ifndef ATOMPROBE_MULTIRANGE_H
#define ATOMPROBE_MULTIRANGE_H

#include <vector>
#include <set>
#include <string>
#include <map>

#include "atomprobe/io/ranges.h"

#include "atomprobe/helper/misc.h"
#include "atomprobe/primitives/ionHit.h"

namespace AtomProbe
{
struct SIMPLE_SPECIES
{
    unsigned int atomicNumber;

    unsigned int count;

    bool operator==(const SIMPLE_SPECIES &oth) const;
};

// a 1D mass axis
struct FLATTENED_RANGE
{
    //Start and end of the "flattened" range
    float startMass,endMass;
    //The ionIDs from parent multirange that are contained between start and end mass
    std::vector<unsigned int> containedIonIDs, containedRangeIDs;
};

bool operator<(const SIMPLE_SPECIES &a, const SIMPLE_SPECIES &b);

enum
{
    MULTIRANGE_FORMAT_XML,
};

class MultiRange
{
    private:
        std::vector<std::string> ionNames;


        std::vector<std::set<SIMPLE_SPECIES> > moleculeData;    

        std::vector<RGBf> colours;
    

        std::vector<std::pair<float,float> > ranges;
        
        // Typically ions that are linked by isotope fingerprint share a grouping identifier.
        // This might be used e.g. for decomposition/deconvolution
        std::vector<unsigned int> rangeGrouping;
        
        std::vector<unsigned int> ionIDs;
        

        unsigned int errState;
    

    public:
        MultiRange();


        MultiRange(const AtomProbe::RangeFile &rng, const AtomProbe::AbundanceData &natData);

        bool operator==(const MultiRange &oth) const;
    
        unsigned int addIon(const std::set<SIMPLE_SPECIES> &molecule, 
                 const std::string &name, const RGBf &ionCol);

    
        unsigned int addIon(const SIMPLE_SPECIES &molecule, 
                 const std::string &name, const RGBf &ionCol);
        

        unsigned int addRange(float start, float end, unsigned int ionID);
        
        unsigned int addRange(const std::pair<float, float> &rng, unsigned int ionID);


        void setRangeGroups(const std::vector<unsigned int> &groups);


        bool write(const char *fileName, unsigned int format=MULTIRANGE_FORMAT_XML) const;


        bool open(const char *fileName, unsigned int format=-1);


        unsigned int getIonID(unsigned int rangeId) const;
        
        void setIonID(unsigned int range, unsigned int newIonId);

        RGBf getColour(unsigned int ionID) const;
        void setColour(unsigned int ionID, const RGBf &r);

        std::string getErrString() const;
        
        std::string getIonName(unsigned int ionID) const;
    
        unsigned int getNumRanges() const;

        unsigned int getNumRanges(unsigned int ionID) const;

        unsigned int getNumIons() const;

        std::set<SIMPLE_SPECIES> getMolecule(unsigned int ionID) const;


        std::pair<float,float> getRange(unsigned int rangeID) const;

        std::vector<unsigned int> getRanges(float mass) const;

    
        bool isRanged(float mass) const;
        bool isRanged(const IonHit &) const;

        void range(std::vector<IonHit> &ionHits) const;

        bool isSelfConsistent() const;

        void clear();


        // - each ion that is in the range is listed
        // - Tolerance is the tolerance in both the + and - directions to extend ranges when considering 
        //   the existence of overlaps
        void flattenToMassAxis(std::vector<FLATTENED_RANGE> &ionMapping,float tolerance=0) const;

        // This will only consider the ranges that exist in the multirange file
        // massTolerance : used to determine overlapping groups, and is +- the range bounds 
        void splitOverlapping(std::vector<MultiRange> &decomposedRanges, float massTolerance=0) const;
        
        
        // such as parent ion, molecule formation data, representation etc.
        // Does not copy group data, as this makes no sense, instead range group data is erased if present
        void copyDataFromRange(const MultiRange &src,unsigned int srcRngId);

#ifdef DEBUG
        static bool testSplit(const AtomProbe::AbundanceData &abundance);
    
        static bool test();
#endif
};

}
#endif