//******************************************************************************
//** SCATMECH: Polarized Light Scattering C++ Class Library
//** 
//** File: dielfunc.h
//**
//** Thomas A. Germer
//** Optical Technology Division, National Institute of Standards and Technology
//** 100 Bureau Dr. Stop 8443; Gaithersburg, MD 20899-8443
//** Phone: (301) 975-2876; FAX: (301) 975-6991
//** Email: thomas.germer@nist.gov
//**
//** Version: 6.00 (February 2008)
//**
//******************************************************************************
#ifndef SCATMECH_DIELFUNC_H
#define SCATMECH_DIELFUNC_H

#include "scatmech.h"
#include "optconst.h"
#include "scattabl.h"
#include "inherit.h"

namespace SCATMECH {

    class dielectric_function {
        public:
            dielectric_function() : n1(), n2()
                    { last_lambda=-1.; }
            dielectric_function(const dielectric_function& df) {*this=df;}
            dielectric_function& operator=(const dielectric_function& df) {
                    n1=df.n1;
                    n2=df.n2;
                    last_eps=df.last_eps; 
                    last_n=df.last_n; 
                    last_lambda=df.last_lambda; 
                    name=df.name; 
                    return *this;
            }
            dielectric_function(const std::string& filename) : n1(), n2()
                    { last_lambda=-1.; set(filename); }
            dielectric_function(const optical_constant& nn);
            dielectric_function(const dielectric_constant& ee);

            void read(const std::string& filename);
        
            dielectric_constant epsilon(double lambda) const {
                update(lambda);
                return last_eps;
            }

            optical_constant index(double lambda) const {
                update(lambda);
                return last_n;
            }

            dielectric_constant epsilon() const {return last_eps;}
            optical_constant index() const {return last_n;}
        
            double e1(double lambda) const {
                update(lambda);
                return last_eps.e1;
            }

            double e2(double lambda) const {
                update(lambda);
                return last_eps.e2;
            }

            double n(double lambda) const {
                update(lambda);
                return last_n.n;
            }

            double k(double lambda) const {
                update(lambda);
                return last_n.k;
            }
        
            static dielectric_function AskUser(const std::string& query, const std::string& deflt);
            static dielectric_function AskUser(const std::string& query,const optical_constant& deflt);

            void force_nonabsorbing();
        
            const std::string& get_name() const {return name;}
            friend std::ostream& operator<<(std::ostream& os,const dielectric_function& df) {return os << df.name;}

            void set_n(const Table& n);
            void set_k(const Table& k);

        private:
            Table n1;
            Table n2;
        
            dielectric_constant last_eps;
            optical_constant last_n;
            double last_lambda;
        
            int _AskUser(const std::string& query,const std::string& deflt);
            int _AskUser(const std::string& query,const optical_constant& deflt);

            void update(double lambda) const {
                if (last_lambda!=lambda) {
                    const_cast<optical_constant& >(last_n) = optical_constant(n1.value(lambda),n2.value(lambda));
                    const_cast<dielectric_constant& >(last_eps) = last_n;
                    const_cast<double&>(last_lambda) = lambda;
                }
            }
                    
            void set(const std::string& value);

            std::string name;
    };

    template <>
    void ModelParameterSet(dielectric_function& variable,const std::string& subparameter,const std::string& value);
    template <>
    std::string ModelParameterGet(dielectric_function& variable,const std::string& subparameter);
    template <>
    void ModelParameterAskUser(dielectric_function& variable,const std::string& prompt);

    extern dielectric_function vacuum_function;

} // namespace SCATMECH 


#endif