codebase / stimlib

  #ifndef RTS_MATERIAL_H
  #define RTS_MATERIAL_H

  
  #include <vector>
  #include <ostream>
  #include <iostream>
  #include <fstream>
  #include <complex>
  #include <algorithm>
  #include <sstream>

  #include "../math/complex.h"
  #include "../math/constants.h"
  #include "../math/function.h"

  namespace rts{
  

  //Material class - default representation for the material property is the refractive index (RI)
  template<typename T>
  class material : public function< T, complex<T> >{

  public:
      enum wave_property{microns, inverse_cm};
      enum material_property{ri, absorbance};

  private:

      using function< T, complex<T> >::X;
      using function< T, complex<T> >::Y;
      using function< T, complex<T> >::insert;
      using function< T, complex<T> >::bounding;

      std::string name;	//name for the material (defaults to file name)

      void process_header(std::string str, wave_property& wp, material_property& mp){

      	std::stringstream ss(str);	//create a stream from the data string
      	std::string line;
      	std::getline(ss, line);		//get the first line as a string
  		while(line[0] == '#'){		//continue looping while the line is a comment

  			std::stringstream lstream(line);	//create a stream from the line
  			lstream.ignore();					//ignore the first character ('#')

  			std::string prop;		//get the property name
  			lstream>>prop;

  			if(prop == "X"){
  				std::string wp_name;
  				lstream>>wp_name;
  				if(wp_name == "microns") wp = microns;
  				else if(wp_name == "inverse_cm") wp = inverse_cm;

  			}

  			else if(prop == "Y"){
  				std::string mp_name;
  				lstream>>mp_name;
  				if(mp_name == "ri") mp = ri;
  				else if(mp_name == "absorbance") mp = absorbance;

  			}
  

  			std::getline(ss, line);		//get the next line
  		}

  		function< T, rts::complex<T> >::process_string(str);
  	}

      void from_inverse_cm(){
      	//convert inverse centimeters to wavelength (in microns)
      	for(unsigned int i=0; i<X.size(); i++)
      		X[i] = 10000 / X[i];

      	//reverse the function array
      	std::reverse(X.begin(), X.end());
      	std::reverse(Y.begin(), Y.end());

      }

      void init(){
      	bounding[0] = bounding[1] = rts::complex<T>(1, 0);
      }

  public:

      material(std::string filename, wave_property wp, material_property mp){
      	name = filename;
      	load(filename, wp, mp);
      }

      material(std::string filename){
      	name = filename;
      	load(filename);
      }

      material(){
      	init();
      }

      complex<T> getN(T lambda){
      	return function< T, complex<T> >::linear(lambda);
      }

      void load(std::string filename, wave_property wp, material_property mp){

      	//load the file as a function
      	function< T, complex<T> >::load(filename);
      }

      void load(std::string filename){
  
      	wave_property wp = inverse_cm;
      	material_property mp = ri;
      	//turn the file into a string
      	std::ifstream t(filename.c_str());	//open the file as a stream
  
      	if(!t){
      		std::cout<<"ERROR: Couldn't open the material file '"<<filename<<"'"<<std::endl;
      		exit(1);
      	}
  		std::string str((std::istreambuf_iterator<char>(t)),
  		std::istreambuf_iterator<char>());
  
  		//process the header information
  		process_header(str, wp, mp);
  
  		//convert units
  		if(wp == inverse_cm)
  			from_inverse_cm();
  		//set the bounding values
  		bounding[0] = Y[0];
  		bounding[1] = Y.back();
      }
      std::string str(){
      	std::stringstream ss;
      	ss<<name<<std::endl;
      	ss<<function< T, complex<T> >::str();
      	return ss.str();
      }
      std::string get_name(){
      	return name;
      }

      void set_name(std::string str){
      	name = str;
      }

  };

  }
  
  
  

  #endif