iphreeqc/Temperature.cxx

// Temperature.cxx: implementation of the cxxTemperature class.
//
//////////////////////////////////////////////////////////////////////
#ifdef _DEBUG
#pragma warning(disable : 4786)   // disable truncation warning (Only used by debugger)
#endif

#include "Utils.h"   // define first
#include "Temperature.h"
#define EXTERNAL extern
#include "global.h"
#include "phqalloc.h"
#include "phrqproto.h"
#include <cassert>     // assert
#include <algorithm>   // std::sort 

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

cxxTemperature::cxxTemperature()
        //
        // default constructor for cxxTemperature 
        //
: cxxNumKeyword()
{
	countTemps                  = 0;
	equalIncrements             = false;
}

cxxTemperature::cxxTemperature(struct temperature *temperature_ptr)
        //
        // constructor for cxxTemperature from struct temperature
        //
: 
cxxNumKeyword()
{
        int i;

        this->set_description(temperature_ptr->description);
        this->n_user                       = temperature_ptr->n_user;     
        this->n_user_end                   = temperature_ptr->n_user_end;  
	// temps
	if (temperature_ptr->count_t < 0) {
		for (i = 0; i < 2; i++) {
			this->temps.push_back(temperature_ptr->t[i]);
		}
		this->countTemps           = -temperature_ptr->count_t;
		this->equalIncrements      = true;
	} else {
		for (i = 0; i < temperature_ptr->count_t; i++) {
			this->temps.push_back(temperature_ptr->t[i]);
		}
		this->countTemps           = temperature_ptr->count_t;
		this->equalIncrements      = false;
	}
}

cxxTemperature::~cxxTemperature()
{
}


struct temperature *cxxTemperature::cxxTemperature2temperature()
        //
        // Builds a temperature structure from instance of cxxTemperature 
        //
{
        struct temperature *temperature_ptr;
	temperature_ptr = (struct temperature *) PHRQ_malloc(sizeof (struct temperature));
        if (temperature_ptr == NULL) malloc_error();

        temperature_ptr->description                 = this->get_description();  
        temperature_ptr->n_user                      = this->n_user;            
        temperature_ptr->n_user_end                  = this->n_user_end;        

	// temps
	temperature_ptr->t = NULL;
        if (this->temps.size() > 0) {
                temperature_ptr->t = (double *) PHRQ_malloc((size_t) (this->temps.size() * sizeof(double)));
                if (temperature_ptr->t == NULL) malloc_error();
                std::copy(this->temps.begin(), this->temps.end(), temperature_ptr->t);
        }
	if (this->equalIncrements) {
		temperature_ptr->count_t         = -this->countTemps;
	} else {
		temperature_ptr->count_t         = this->temps.size();
	}
        return(temperature_ptr);
}

#ifdef SKIP
void cxxTemperature::dump_xml(std::ostream& s_oss, unsigned int indent)const
{
        //const char    ERR_MESSAGE[] = "Packing temperature message: %s, element not found\n";
        unsigned int i;
        s_oss.precision(DBL_DIG - 1);
        std::string indent0(""), indent1(""), indent2("");
        for(i = 0; i < indent; ++i) indent0.append(Utilities::INDENT);
        for(i = 0; i < indent + 1; ++i) indent1.append(Utilities::INDENT);
        for(i = 0; i < indent + 2; ++i) indent2.append(Utilities::INDENT);

        // Temperature element and attributes
        s_oss << indent0;
        s_oss << "<temperature " << std::endl;

        s_oss << indent1;
        s_oss << "pitzer_temperature_gammas=\"" << this->pitzer_temperature_gammas << "\"" << std::endl;

        // components
        s_oss << indent1;
        s_oss << "<component " << std::endl;
        for (std::list<cxxTemperatureComp>::const_iterator it = temperatureComps.begin(); it != temperatureComps.end(); ++it) {
                it->dump_xml(s_oss, indent + 2);
        }

        return;
}
#endif

void cxxTemperature::dump_raw(std::ostream& s_oss, unsigned int indent)const
{
        //const char    ERR_MESSAGE[] = "Packing temperature message: %s, element not found\n";
        unsigned int i;
        s_oss.precision(DBL_DIG - 1);
        std::string indent0(""), indent1(""), indent2("");
        for(i = 0; i < indent; ++i) indent0.append(Utilities::INDENT);
        for(i = 0; i < indent + 1; ++i) indent1.append(Utilities::INDENT);
        for(i = 0; i < indent + 2; ++i) indent2.append(Utilities::INDENT);

        // Temperature element and attributes
        s_oss << indent0;
        s_oss << "REACTION_TEMPERATURE_RAW        " << this->n_user  << " " << this->description << std::endl;

        s_oss << indent1;
        s_oss << "-temps              "  << std::endl;
        {
                int i = 0;
                s_oss << indent2;
                for (std::vector<double>::const_iterator it = this->temps.begin(); it != this->temps.end(); it++) {
                        if (i++ == 5) {
                                s_oss << std::endl;
                                s_oss << indent2;
                                i = 0;
                        }
                        s_oss << *it << " ";
                }
                s_oss << std::endl;
        }       

        s_oss << indent1;
        s_oss << "-equal_increments   " << this->equalIncrements << std::endl;

        s_oss << indent1;
        s_oss << "-count_temps        " << this->countTemps << std::endl;


}

void cxxTemperature::read_raw(CParser& parser)
{

        double d;
	CParser::TOKEN_TYPE k;
        static std::vector<std::string> vopts;
        if (vopts.empty()) {
                vopts.reserve(15);
                vopts.push_back("temps");                  //0
                vopts.push_back("equal_increments");       //1
                vopts.push_back("count_temps");            //2
        }                                                      
                                                               
        std::istream::pos_type ptr;                            
        std::istream::pos_type next_char;                      
        std::string token;                                     
        int opt_save;
        bool useLastLine(false);

        // Read temperature number and description
        this->read_number_description(parser);

        opt_save = CParser::OPT_ERROR;
        bool equalIncrements_defined(false); 
        bool countTemps_defined(false); 

        for (;;)
        {
                int opt;
                if (useLastLine == false) {
                        opt = parser.get_option(vopts, next_char);
                } else {
                        opt = parser.getOptionFromLastLine(vopts, next_char);
                }
                if (opt == CParser::OPT_DEFAULT)
                {
                        opt = opt_save;
                }
                switch (opt)
                {
                case CParser::OPT_EOF:
                        break;
                case CParser::OPT_KEYWORD:
                        break;
                case CParser::OPT_DEFAULT:
                case CParser::OPT_ERROR:
                        opt = CParser::OPT_EOF;
                        parser.error_msg("Unknown input in TEMPERATURE_COMP_RAW keyword.", CParser::OT_CONTINUE);
                        parser.error_msg(parser.line().c_str(), CParser::OT_CONTINUE);
                        useLastLine = false;
                        break;

                case 0: // temps
                        while ((k = parser.copy_token(token, next_char)) == CParser::TT_DIGIT) {
				std::istringstream iss(token);
				if (!(iss >> d)) {
					parser.incr_input_error();
					parser.error_msg("Expected numeric value for temps.", CParser::OT_CONTINUE);
				} else {
					this->temps.push_back(d);
				}
                        }
                        opt_save = 0;
                        useLastLine = false;
                        break;

                case 1: // equal_increments
                        if (!(parser.get_iss() >> this->equalIncrements))
                        {
                                this->equalIncrements = 0;
                                parser.incr_input_error();
                                parser.error_msg("Expected boolean value for equalIncrements.", CParser::OT_CONTINUE);
                        }
                        opt_save = CParser::OPT_DEFAULT;
                        useLastLine = false;
                        equalIncrements_defined = true;
                        break;

                case 2: // countTemps
                        if (!(parser.get_iss() >> this->countTemps))
                        {
                                this->countTemps = 0;
                                parser.incr_input_error();
                                parser.error_msg("Expected integer value for countTemps.", CParser::OT_CONTINUE);
                        }
                        opt_save = CParser::OPT_DEFAULT;
                        useLastLine = false;
                        countTemps_defined = true;
                        break;
                }
                if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD) break;
        }
        // members that must be defined
        if (equalIncrements_defined == false) {
                parser.incr_input_error();
                parser.error_msg("Equal_increments not defined for REACTION_TEMPERATURE_RAW input.", CParser::OT_CONTINUE);
        }
        if (countTemps_defined == false) {
                parser.incr_input_error();
                parser.error_msg("Count_temps not defined for REACTION_TEMPERATURE_RAW input.", CParser::OT_CONTINUE);
        }
}