ranges.h

Go to the documentation of this file.

/*
 * ranges.h - Atom probe rangefile class 
 * Copyright (C) 2018  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_APTRANGES_H
#define ATOMPROBE_APTRANGES_H

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

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

namespace AtomProbe
{


//Number of elements stored in the table
const unsigned int NUM_ELEMENTS=119;

enum{ RANGE_FORMAT_ORNL,
    RANGE_FORMAT_DBL_ORNL,
    RANGE_FORMAT_ENV,
    RANGE_FORMAT_RRNG,
    RANGE_FORMAT_END_OF_ENUM //not a format, just end of enumeration.
};

enum
{
    RANGE_ERR_FORMAT=1,
    RANGE_ERR_FORMAT_HEADER,
    RANGE_ERR_EMPTY,
    RANGE_ERR_FORMAT_LONGNAME,
    RANGE_ERR_FORMAT_SHORTNAME,
    RANGE_ERR_FORMAT_COLOUR,
    RANGE_ERR_FORMAT_TABLESEPARATOR,
    RANGE_ERR_FORMAT_RANGE_DUMMYCHARS,
    RANGE_ERR_FORMAT_MASS_PAIR,
    RANGE_ERR_FORMAT_TABLE_ENTRY,
    PARSE_RANGE_FORMAT_GENERIC_FAIL,
    RANGE_ERR_DATA_TOO_MANY_USELESS_RANGES,
    RANGE_ERR_DATA_FLIPPED,
    RANGE_ERR_DATA_INCONSISTENT,
    RANGE_ERR_DATA_NOMAPPED_IONNAME,
    RANGE_ERR_OPEN, 
    RANGE_ERR_FORMAT_RANGETABLE,    
    RANGE_ERR_FORMAT_TABLEHEADER_NUMIONS,
    RANGE_ERR_NONUNIQUE_POLYATOMIC,
    RANGE_ERR_TOO_LARGE,
    RANGE_ERR_DASHHEADER,
    RANGE_ERR_IONBLOCK_CONTENT,
    RANGE_ERR_NUMIONS,
    RANGE_ERR_NUMIONS_DUPLICATED,
    RANGE_ERR_TOO_MANYIONS,
    RANGE_ERR_ION_BLOCK_NOT_PRESENT,
    RANGE_ERR_DUPLICATE_NUMRANGES,
    RANGE_ERR_NUMRANGE_PARSE,
    RANGE_ERR_RRNG_IONS_TOOSHORT,
    RANGE_ERR_RRNG_COLON_SEPARATOR,
    RANGE_ERR_BADCOLOUR,
    RANGE_ERR_ION_NOT_MAPPED,
    RANGE_ERR_BADSTART,
    RANGE_ERR_BADEND,
    RANGE_ERR_NAME_EMPTY,
    RANGE_ERR_BAD_LINE_RANGEBLOCK,
    RANGE_ERR_MISSING_IONBLOCK,
    RANGE_ERR_NO_RANGES,
    RANGE_ERR_NO_BASIC_IONS,
    RANGE_ERR_MISMATCHED_NUMRANGES,
    RANGE_ERR_RANGEBLOCK_FORMAT,
    RANGE_ERR_BAD_MULTIPLICITY,
    RANGE_ERR_VOLUME_PARSE,
    RANGE_ERR_FORMAT_EMPTY_RANGEROW,
    RANGE_ERR_FILESIZE,
    RANGE_ERR_ENUM_END
};

class RangeFile
{
    private:

        std::vector<std::pair<std::string,std::string> > ionNames;



        std::vector< std::map<std::string,size_t> > ionFormulas;



        std::vector<RGBf> colours;



        std::vector<std::pair<float,float> > ranges;


        std::vector<unsigned int> ionIDs;


        std::vector<float> rangeVolumes;


        /* Can get human readable error string with getErrString
         * \see {RangeFile::getErrString(), RangeFile::getErrState()}
        */
        unsigned int errState;


        /* Vector of strings detailing potential problems.        */
        std::vector<std::string> warnMessages;


        void clear();


        // caller must supply and release file pointer
        unsigned int openRNG(FILE *fp);


        static unsigned int readRNGHeader(FILE *fpRange,
                          std::vector<std::pair<std::string,std::string> > &strNames,
                          std::vector<RGBf> &fileColours, unsigned int &numRanges,
                          unsigned int &numIons);


        static unsigned int readRNGFreqTable(FILE *fpRange, char *inBuffer,
                             const unsigned int numIons, const unsigned int numRanges,
                             const std::vector<std::pair<std::string,std::string> > &names,
                             std::vector<std::string> &colHeaders,
                             std::vector<unsigned int > &tableEntries,
                             std::vector<std::pair<float,float> > &massData,
                             std::vector<std::string> &warnings);

        unsigned int openDoubleRNG(FILE *fp);


        // caller must supply and release file pointer
        unsigned int openRRNG(FILE *fp);
        // caller must supply and release file pointer
        unsigned int openENV(FILE *fp);

        static std::string envDropChargeState(const std::string &strName);

        static bool enforceConsistency;

    public:
        RangeFile();

        const RangeFile& operator=(const RangeFile &other);
        bool open(const char *rangeFile);

        // - Can get human readable error string with getErrString
        unsigned int openFormat(const char *rangeFile, unsigned int format);

        static bool extensionIsRange(const char *ext);
        static void getAllExts(std::vector<std::string> &exts);


        static unsigned int detectFileType(const char *file);

        static std::string rangeTypeString(unsigned int rangeType);

        static void setEnforceConsistent(bool shouldEnforce=true) {
            enforceConsistency=shouldEnforce;
        }

        /* Checks for ranges of zero width, overlapping ranges and duplicate ranges.
         * Can be fixed with makeSelfConsistent.
         * */
        bool isSelfConsistent() const;

        bool isSelfConsistent(std::vector<std::string> &consistencyMessages) const;


        bool makeSelfConsistent();

        std::string getErrString() const;

        unsigned int getErrState() const { return errState; }

        unsigned int getNumRanges() const;
        unsigned int getNumRanges(unsigned int ionID) const;
        unsigned int getNumIons() const;

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

        std::pair<float,float> &getRangeByRef(unsigned int );

        bool haveRangeVolumes() const;

        float getRangeVolume(unsigned int rangeId) const;
        void setRangeVolume(unsigned int rangeId, float newVolume) ;

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



        unsigned int getIonID(float mass) const;


        unsigned int getIonID(const IonHit &hit) const;

        unsigned int getIonID(unsigned int range) const;

        unsigned int getIonID(const char *name, bool useShortName=true) const;
        unsigned int getIonID(const std::string &name) const {return getIonID(name.c_str());};

        void setIonID(unsigned int range, unsigned int newIonId);



        // Ion formula get/set

        std::map<std::string,size_t> getIonFormula(unsigned int ionID) const;


        void setIonFormula(const std::string &name, const std::map<std::string,size_t> &formula, bool useShortName=true);

        void setIonFormula(const unsigned int ionID,const std::map<std::string,size_t> &formula);


        void guessFormulas(bool overwrite=false); 
        
        void clearFormulas() { ionFormulas.clear();}; 

        bool isRanged(float mass) const;

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

        void rangeInvertable(std::vector<IonHit> &ionHits, bool invert);


        bool range(std::vector<IonHit> &ionHits,
               const std::string &shortIonName);


        bool rangeByID(std::vector<IonHit> &ionHits,
                   unsigned int range);


        void rangeByRangeID(std::vector<IonHit> &ionHits,
                    unsigned int rangeID);

        void extractIons(const std::vector<IonHit> &ionHits,
                 const std::vector<unsigned int> &ionIDs, std::vector<IonHit> &hits) const;

        std::string getName(unsigned int ionID,bool shortName=true) const;

        std::string getName(const IonHit &ion, bool shortName=true) const;


        void setIonShortName(unsigned int ionID, const std::string &newName);


        void setIonLongName(unsigned int ionID, const std::string &newName);


        bool isRanged(std::string shortName, bool caseSensitive=true);

        // RANGE_FORMAT_DBL_ORNL is not supported for write
        unsigned int write(std::ostream &o,size_t format=RANGE_FORMAT_ORNL) const;
        unsigned int write(const char *datafile, size_t format=RANGE_FORMAT_ORNL) const;


        unsigned int getRangeID(float mass) const;

        void swap(RangeFile &rng);

        bool moveRange(unsigned int range, bool limit, float newMass);
        bool moveBothRanges(unsigned int range, float newLow, float newHigh);


        unsigned int addRange(float start, float end, unsigned int ionID);


        unsigned int addIon(const std::string &shortName, const std::string &longName, const RGBf &ionCol);


        bool setRangeStart(unsigned int rangeID, float v);

        bool setRangeEnd(unsigned int rangeID, float v);

        void eraseRange(unsigned int rangeId) ;

        void eraseIon(unsigned int ionId);

        static bool decomposeIonNames(const std::string &name,

                          std::vector<std::pair<std::string,size_t> > &fragments);

        bool decomposeIonById(unsigned int ionId,
                      std::vector<std::pair<std::string,size_t> > &fragments) const;


        static void decomposeIonNameToFormula(const std::string &name, std::map<std::string,size_t> &formula);

        // returns false if unable to guess the charge state within tolerances
        bool guessChargeState(unsigned int rangeId,
                      const AtomProbe::AbundanceData &massTable, unsigned int &charge,
                      float tolerance=0.5f) const;

#ifdef DEBUG
        //run unit tests, return true on success
        static bool test();
#endif
};



}

#endif