species.h

Go to the documentation of this file.

#ifndef CHEMMISOL_SPECIES_H
#define CHEMMISOL_SPECIES_H
 
#include <vector>
#include <complex>
#include "../units.h"
 
namespace chemmisol {
    enum Phase {
        SOLVENT, AQUEOUS, MINERAL
    };
 
    std::ostream& operator<<(std::ostream& o, const Phase& phase);
 
    class ChemicalSpecies {
        private:
            std::string name;
            std::size_t index;
 
        protected:
            ChemicalSpecies(const std::string& name, std::size_t index)
                : name(name), index(index) {
                }
 
        public:
            const std::string& getName() const {
                return name;
            }
 
            std::size_t getIndex() const {
                return index;
            }
 
            virtual Phase getPhase() const = 0;
 
            virtual void incrementConcentration(double extent) = 0;
 
            virtual double concentration() const = 0;
 
            virtual double concentration(double quantity) const = 0;
 
            double activity() const {
                return activity(concentration());
            }
 
            virtual double activity(double concentration) const = 0;
 
            double quantity() const {
                return quantity(activity());
            }
 
            virtual double quantity(double activity) const = 0;
 
            virtual std::complex<double> quantity(std::complex<double> activity) const = 0;
 
            virtual void setActivity(double activity) = 0;
 
            virtual ~ChemicalSpecies() {
            }
    };
 
    
    class FixedChemicalSpecies : public ChemicalSpecies {
        private:
            double C;
            double A;
            double Q;
 
        protected:
            FixedChemicalSpecies(
                    const std::string& name, std::size_t index,
                    double C, double A, double Q
                    )
                : ChemicalSpecies(name, index), C(C), A(A), Q(Q) {
                }
 
        public:
            void incrementConcentration(double) override {
            }
 
            double concentration() const override {
                return C;
            }
 
            double concentration(double /*quantity*/) const override {
                return C;
            }
 
            double quantity(double /*activity*/) const override {
                return Q;
            }
 
            std::complex<double> quantity(std::complex<double> /*activity*/) const override {
                return Q;
            }
 
            double activity(double /*concentration*/) const override {
                return A;
            }
 
            void setActivity(double) override {
            }
    };
 
    class AqueousSpecies : public ChemicalSpecies {
        private:
            double C;
        
        public:
            static const double V;
 
            AqueousSpecies(
                    const std::string& name, std::size_t id,
                    double C)
                : ChemicalSpecies(name, id), C(C) {
                }
 
            Phase getPhase() const override {
                return AQUEOUS;
            }
 
            void incrementConcentration(double extent) override {
                C+=extent/V;
            }
 
            double concentration() const override {
                return C;
            }
 
            double concentration(double quantity) const override {
                return quantity/V;
            }
 
            double quantity(double activity) const override {
                return activity*V*(1*mol/l);
            }
 
            std::complex<double> quantity(std::complex<double> activity) const override {
                return activity*V*(1*mol/l);
            }
 
            double activity(double concentration) const override {
                return concentration/(1*mol/l);
            }
 
            void setActivity(double activity) override {
                C = activity * 1*mol/l;
            }
    };
 
    class FixedAqueousSpecies : public FixedChemicalSpecies {
        public:
            FixedAqueousSpecies(
                    const std::string& name, std::size_t index,
                    double C)
                : FixedChemicalSpecies(name, index, C, C/(1*mol/l), C*AqueousSpecies::V) {
                }
 
            Phase getPhase() const override {
                return AQUEOUS;
            }
    };
 
    class Solvent : public FixedAqueousSpecies {
        public:
            Solvent(const std::string& name, std::size_t id)
                : FixedAqueousSpecies(name, id, 1*mol/l) {
                }
 
            Phase getPhase() const override {
                return SOLVENT;
            }
    };
 
    class MineralSpecies : public ChemicalSpecies {
        private:
            double fraction; // S/N
            double N;
 
        public:
            static double sites_quantity(
                    double solid_concentration,
                    double specific_surface_area,
                    double site_concentration);
 
            // TODO: it is not efficient to specify solid parameters for ALL
            // MineralSpecies
            MineralSpecies(
                    const std::string& name, std::size_t index,
                    double solid_concentration,
                    double specific_surface_area,
                    double site_concentration,
                    double fraction)
                : ChemicalSpecies(name, index), fraction(fraction),
                N(sites_quantity(solid_concentration, specific_surface_area, site_concentration)) {
                }
            
            Phase getPhase() const override {
                return MINERAL;
            }
 
            void incrementConcentration(double extent) override {
                fraction+=extent/N;
            }
 
            double concentration() const override {
                return fraction;
            }
 
            double concentration(double quantity) const override {
                return quantity/N;
            }
 
            double quantity(double activity) const override {
                return activity * N;
            }
 
            std::complex<double> quantity(std::complex<double> activity) const override {
                return activity * N;
            }
 
            double activity(double concentration) const override {
                return concentration;
            }
 
            void setActivity(double activity) override {
                fraction = activity;
            }
    };
 
    class FixedMineralSpecies : public FixedChemicalSpecies {
        public:
            FixedMineralSpecies(
                    const std::string& name, std::size_t index,
                    double solid_concentration,
                    double specific_surface_area,
                    double site_concentration,
                    double F
                    )
                : FixedChemicalSpecies(name, index, F, F,
                        MineralSpecies::sites_quantity(
                            solid_concentration, specific_surface_area,
                            site_concentration
                            )*F) {
                }
 
            Phase getPhase() const override {
                return MINERAL;
            }
    };
 
    class ChemicalComponent {
        private:
            ChemicalSpecies* species;
            std::size_t index;
            double total_quantity;
 
        public:
            ChemicalComponent(
                    ChemicalSpecies* species,
                    std::size_t index, double total_quantity)
                : species(species), index(index), total_quantity(total_quantity) {
                }
 
            ChemicalSpecies* getSpecies() {
                return species;
            }
 
            const ChemicalSpecies* getSpecies() const {
                return species;
            }
 
            std::size_t getIndex() const {
                return index;
            }
 
            virtual bool isFixed() const {
                return false;
            }
 
            double getTotalQuantity() const {
                return total_quantity;
            }
 
            void setTotalQuantity(double quantity) {
                total_quantity = quantity;
            }
 
            void setTotalConcentration(double concentration) {
                setTotalQuantity(species->quantity(species->activity(concentration)));
            }
 
            virtual ~ChemicalComponent() {
            }
    };
 
    class FixedChemicalComponent : public ChemicalComponent {
        public:
            FixedChemicalComponent(
                    FixedChemicalSpecies* species,
                    std::size_t index)
                : ChemicalComponent(species, index, species->ChemicalSpecies::quantity()) {
                }
 
            virtual bool isFixed() const override {
                return true;
            }
    };
 
}
#endif /*CHEMMISOL_SPECIES_H*/