pyEQL 1.4.0rc9__cp311-cp311-macosx_10_9_x86_64.whl

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/dense.h

@@ -0,0 +1,341 @@
+#ifndef _INC_DENSE_H
+#define _INC_DENSE_H
+/**************************************************************************
+ *                                                                        *
+ * File          : dense.h                                                *
+ * Programmers   : Scott D. Cohen, Alan C. Hindmarsh, and                 *
+ *                 Radu Serban @ LLNL                                     *
+ * Version of    : 26 June 2002                                           *
+ *------------------------------------------------------------------------*
+ * Copyright (c) 2002, The Regents of the University of California        *
+ * Produced at the Lawrence Livermore National Laboratory                 *
+ * All rights reserved                                                    *
+ * For details, see LICENSE below                                         *
+ *------------------------------------------------------------------------*
+ * This is the header file for a generic DENSE linear solver              *
+ * package.  The routines listed in this file all use type                *
+ * DenseMat, defined below, for matrices.  These routines in turn         *
+ * call routines in the smalldense.h/smalldense.c module, which           *
+ * use the type realtype** for matrices.  This separation allows          *
+ * for possible modifications in which matrices of type DenseMat          *
+ * may not be stored contiguously, while small matrices can still         *
+ * be treated with the routines in smalldense.                            *
+ *                                                                        *
+ * Routines that work with the type DenseMat begin with "Dense".          *
+ * The DenseAllocMat function allocates a dense matrix for use in         *
+ * the other DenseMat routines listed in this file. Matrix                *
+ * storage details are given in the documentation for the type            *
+ * DenseMat. The DenseAllocPiv function allocates memory for              *
+ * pivot information. The storage allocated by DenseAllocMat and          *
+ * DenseAllocPiv is deallocated by the routines DenseFreeMat and          *
+ * DenseFreePiv, respectively. The DenseFactor and DenseBacksolve         *
+ * routines perform the actual solution of a dense linear system.         *
+ *                                                                        *
+ * Routines that work with realtype** begin with "den" (except for        *
+ * the factor and solve routines which are called gefa and gesl,          *
+ * respectively). The underlying matrix storage is described in           *
+ * the documentation for denalloc in smalldense.h                         *
+ *                                                                        *
+ *------------------------------------------------------------------------*
+ * LICENSE                                                                *
+ *------------------------------------------------------------------------*
+ * Copyright (c) 2002, The Regents of the University of California.       *
+ * Produced at the Lawrence Livermore National Laboratory.                *
+ * Written by S.D. Cohen, A.C. Hindmarsh, R. Serban,                      *
+ *            D. Shumaker, and A.G. Taylor.                               *
+ * UCRL-CODE-155951    (CVODE)                                            *
+ * UCRL-CODE-155950    (CVODES)                                           *
+ * UCRL-CODE-155952    (IDA)                                              *
+ * UCRL-CODE-237203    (IDAS)                                             *
+ * UCRL-CODE-155953    (KINSOL)                                           *
+ * All rights reserved.                                                   *
+ *                                                                        *
+ * This file is part of SUNDIALS.                                         *
+ *                                                                        *
+ * Redistribution and use in source and binary forms, with or without     *
+ * modification, are permitted provided that the following conditions     *
+ * are met:                                                               *
+ *                                                                        *
+ * 1. Redistributions of source code must retain the above copyright      *
+ * notice, this list of conditions and the disclaimer below.              *
+ *                                                                        *
+ * 2. Redistributions in binary form must reproduce the above copyright   *
+ * notice, this list of conditions and the disclaimer (as noted below)    *
+ * in the documentation and/or other materials provided with the          *
+ * distribution.                                                          *
+ *                                                                        *
+ * 3. Neither the name of the UC/LLNL nor the names of its contributors   *
+ * may be used to endorse or promote products derived from this software  *
+ * without specific prior written permission.                             *
+ *                                                                        *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS    *
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT      *
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS      *
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE         *
+ * REGENTS OF THE UNIVERSITY OF CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY *
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,        *
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT       *
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,  *
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY  *
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT    *
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE  *
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.   *
+ **************************************************************************/
+#ifndef _dense_h
+#define _dense_h
+
+
+#include "sundialstypes.h"
+#include "smalldense.h"
+
+
+/******************************************************************
+ *                                                                *
+ * Type: DenseMat                                                 *
+ *----------------------------------------------------------------*
+ * The type DenseMat is defined to be a pointer to a structure    *
+ * with a size and a data field. The size field indicates the     *
+ * number of columns (== number of rows) of a dense matrix, while *
+ * the data field is a two dimensional array used for component   *
+ * storage. The elements of a dense matrix are stored columnwise  *
+ * (i.e columns are stored one on top of the other in memory). If *
+ * A is of type DenseMat, then the (i,j)th element of A (with     *
+ * 0 <= i,j <= size-1) is given by the expression (A->data)[j][i] *
+ * or by the expression (A->data)[0][j*n+i]. The macros below     *
+ * allow a user to access efficiently individual matrix           *
+ * elements without writing out explicit data structure           *
+ * references and without knowing too much about the underlying   *
+ * element storage. The only storage assumption needed is that    *
+ * elements are stored columnwise and that a pointer to the jth   *
+ * column of elements can be obtained via the DENSE_COL macro.    *
+ * Users should use these macros whenever possible.               *
+ *                                                                *
+ ******************************************************************/
+
+	typedef struct _DenseMat
+	{
+		integertype size;
+		realtype **data;
+	} *DenseMat;
+
+
+/* DenseMat accessor macros */
+
+
+/******************************************************************
+ *                                                                *
+ * Macro : DENSE_ELEM                                             *
+ * Usage : DENSE_ELEM(A,i,j) = a_ij;  OR                          *
+ *         a_ij = DENSE_ELEM(A,i,j);                              *
+ *----------------------------------------------------------------*
+ * DENSE_ELEM(A,i,j) references the (i,j)th element of the N by N *
+ * DenseMat A, 0 <= i,j <= N-1.                                   *
+ *                                                                *
+ ******************************************************************/
+
+#define DENSE_ELEM(A,i,j) ((A->data)[j][i])
+
+
+/******************************************************************
+ *                                                                *
+ * Macro : DENSE_COL                                              *
+ * Usage : col_j = DENSE_COL(A,j);                                *
+ *----------------------------------------------------------------*
+ * DENSE_COL(A,j) references the jth column of the N by N         *
+ * DenseMat A, 0 <= j <= N-1. The type of the expression          *
+ * DENSE_COL(A,j) is realtype *. After the assignment in the usage*
+ * above, col_j may be treated as an array indexed from 0 to N-1. *
+ * The (i,j)th element of A is referenced by col_j[i].            *
+ *                                                                *
+ ******************************************************************/
+
+#define DENSE_COL(A,j) ((A->data)[j])
+
+
+/* Functions that use the DenseMat representation for a dense matrix */
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseAllocMat                                       *
+ * Usage    : A = DenseAllocMat(N);                               *
+ *            if (A == NULL) ... memory request failed            *
+ *----------------------------------------------------------------*
+ * DenseAllocMat allocates memory for an N by N dense matrix and  *
+ * returns the storage allocated (type DenseMat). DenseAllocMat   *
+ * returns NULL if the request for matrix storage cannot be       *
+ * satisfied. See the above documentation for the type DenseMat   *
+ * for matrix storage details.                                    *
+ *                                                                *
+ ******************************************************************/
+
+	DenseMat DenseAllocMat(integertype N);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseAllocPiv                                       *
+ * Usage    : p = DenseAllocPiv(N);                               *
+ *            if (p == NULL) ... memory request failed            *
+ *----------------------------------------------------------------*
+ * DenseAllocPiv allocates memory for pivot information to be     *
+ * filled in by the DenseFactor routine during the factorization  *
+ * of an N by N dense matrix. The underlying type for pivot       *
+ * information is an array of N integers and this routine returns *
+ * the pointer to the memory it allocates. If the request for     *
+ * pivot storage cannot be satisfied, DenseAllocPiv returns NULL. *
+ *                                                                *
+ ******************************************************************/
+
+	integertype *DenseAllocPiv(integertype N);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseFactor                                         *
+ * Usage    : ier = DenseFactor(A, p);                            *
+ *            if (ier != 0) ... A is singular                     *
+ *----------------------------------------------------------------*
+ * DenseFactor performs the LU factorization of the N by N dense  *
+ * matrix A. This is done using standard Gaussian elimination     *
+ * with partial pivoting.                                         *
+ *                                                                *
+ * A successful LU factorization leaves the matrix A and the      *
+ * pivot array p with the following information:                  *
+ *                                                                *
+ * (1) p[k] contains the row number of the pivot element chosen   *
+ *     at the beginning of elimination step k, k=0, 1, ..., N-1.  *
+ *                                                                *
+ * (2) If the unique LU factorization of A is given by PA = LU,   *
+ *     where P is a permutation matrix, L is a lower triangular   *
+ *     matrix with all 1's on the diagonal, and U is an upper     *
+ *     triangular matrix, then the upper triangular part of A     *
+ *     (including its diagonal) contains U and the strictly lower *
+ *     triangular part of A contains the multipliers, I-L.        *
+ *                                                                *
+ * DenseFactor returns 0 if successful. Otherwise it encountered  *
+ * a zero diagonal element during the factorization. In this case *
+ * it returns the column index (numbered from one) at which       *
+ * it encountered the zero.                                       *
+ *                                                                *
+ ******************************************************************/
+
+	integertype DenseFactor(DenseMat A, integertype * p);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseBacksolve                                      *
+ * Usage    : DenseBacksolve(A, p, b);                            *
+ *----------------------------------------------------------------*
+ * DenseBacksolve solves the N-dimensional system A x = b using   *
+ * the LU factorization in A and the pivot information in p       *
+ * computed in DenseFactor. The solution x is returned in b. This *
+ * routine cannot fail if the corresponding call to DenseFactor   *
+ * did not fail.                                                  *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseBacksolve(DenseMat A, integertype * p, realtype * b);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseZero                                           *
+ * Usage    : DenseZero(A);                                       *
+ *----------------------------------------------------------------*
+ * DenseZero sets all the elements of the N by N matrix A to 0.0. *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseZero(DenseMat A);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseCopy                                           *
+ * Usage    : DenseCopy(A, B);                                    *
+ *----------------------------------------------------------------*
+ * DenseCopy copies the contents of the N by N matrix A into the  *
+ * N by N matrix B.                                               *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseCopy(DenseMat A, DenseMat B);
+
+
+/******************************************************************
+ *                                                                *
+ * Function: DenseScale                                           *
+ * Usage   : DenseScale(c, A);                                    *
+ *----------------------------------------------------------------*
+ * DenseScale scales the elements of the N by N matrix A by the   *
+ * constant c and stores the result back in A.                    *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseScale(realtype c, DenseMat A);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseAddI                                           *
+ * Usage    : DenseAddI(A);                                       *
+ *----------------------------------------------------------------*
+ * DenseAddI adds the identity matrix to A and stores the result  *
+ * back in A.                                                     *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseAddI(DenseMat A);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseFreeMat                                        *
+ * Usage    : DenseFreeMat(A);                                    *
+ *----------------------------------------------------------------*
+ * DenseFreeMat frees the memory allocated by DenseAllocMat for   *
+ * the N by N matrix A.                                           *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseFreeMat(DenseMat A);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DenseFreePiv                                        *
+ * Usage    : DenseFreePiv(p);                                    *
+ *----------------------------------------------------------------*
+ * DenseFreePiv frees the memory allocated by DenseAllocPiv for   *
+ * the pivot information array p.                                 *
+ *                                                                *
+ ******************************************************************/
+
+	void DenseFreePiv(integertype * p);
+
+
+/******************************************************************
+ *                                                                *
+ * Function : DensePrint                                          *
+ * Usage    : DensePrint(A);                                      *
+ *----------------------------------------------------------------*
+ * This routine prints the N by N dense matrix A to standard      *
+ * output as it would normally appear on paper. It is intended    *
+ * as a debugging tool with small values of N. The elements are   *
+ * printed using the %g option. A blank line is printed before    *
+ * and after the matrix.                                          *
+ *                                                                *
+ ******************************************************************/
+
+	void DensePrint(DenseMat A);
+
+
+#endif
+/*
+#ifdef __cplusplus
+}
+#endif
+*/
+#endif /* _INC_DENSE_H */

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/dumper.cpp

@@ -0,0 +1,277 @@
+#include <algorithm>			// std::replace
+
+#include "dumper.h"
+#include "Parser.h"
+#include "PHRQ_io.h"
+
+#if defined(PHREEQCI_GUI)
+#ifdef _DEBUG
+#define new DEBUG_NEW
+#undef THIS_FILE
+static char THIS_FILE[] = __FILE__;
+#endif
+#endif
+
+dumper::dumper(PHRQ_io *io)
+:
+PHRQ_base(io)
+{
+	this->file_name = "dump.out";
+	this->append = false;
+	this->on = false;
+}
+dumper::dumper(CParser & parser, PHRQ_io *io)
+:
+PHRQ_base(io)
+{
+	this->file_name = "dump.out";
+	this->append = false;
+	this->Read(parser);
+}
+
+dumper::~dumper(void)
+{
+}
+
+void dumper::SetAll(bool tf)
+{
+	this->binList.SetAll(tf);
+
+}
+bool dumper::Read(CParser & parser)
+{
+	bool return_value(true);
+
+	std::istream::pos_type ptr;
+	std::istream::pos_type next_char;
+	std::string token;
+	int opt_save;
+
+	opt_save = CParser::OPT_DEFAULT;
+	bool cleared_once = false;
+	this->on = true;
+
+	for (;;)
+	{
+		int opt;
+		StorageBinListItem cells;
+		opt = parser.get_option(vopts, next_char);
+		if (opt == CParser::OPT_DEFAULT)
+		{
+			opt = opt_save;
+		}
+		else
+		{
+			opt_save = opt;
+		}
+		if (opt > 1 && !cleared_once)
+		{
+			binList.SetAll(false);
+			cleared_once = true;
+		}
+		// Select StorageBinListItem
+		StorageBinListItem *item = NULL;
+		switch (opt)
+		{
+		case 3:					// cell
+		case 4:					// cells
+			item = &cells;
+			break;
+		case 5:
+		case 6:
+			item = &(this->binList.Get_solution());
+			break;
+		case 7:
+		case 8:
+		case 9:
+		case 10:
+			item = &(this->binList.Get_pp_assemblage());
+			break;
+		case 11:
+			item = &(this->binList.Get_exchange());
+			break;
+		case 12:
+			item = &(this->binList.Get_surface());
+			break;
+		case 13:
+		case 14:
+		case 15:
+			item = &(this->binList.Get_ss_assemblage());
+			break;
+		case 16:
+		case 17:
+			item = &(this->binList.Get_gas_phase());
+			break;
+		case 18:
+			item = &(this->binList.Get_kinetics());
+			break;
+
+		case 19:	// mix
+			item = &(this->binList.Get_mix());
+			break;
+		case 20:	// reaction
+		case 21:	// reactions
+			item = &(this->binList.Get_reaction());
+			break;
+		case 22:	// temperature
+		case 23:	// reaction_temperature
+		case 24:    // reaction_temperatures
+			item = &(this->binList.Get_temperature());
+			break;
+		case 25:	// pressure
+		case 26:	// reaction_pressure
+		case 27:    // reaction_pressures
+			item = &(this->binList.Get_pressure());
+			break;
+		default:
+			break;
+		}
+
+		// Read dump entity list of numbers or number ranges for line, store in item
+		if ((opt > 2))
+		{
+			for (;;)
+			{ 
+				CParser::TOKEN_TYPE j = parser.copy_token(token, next_char);
+				if (item && j == CParser::TT_DIGIT)
+				{
+					item->Augment(token);
+				}
+				else if (item && j == CParser::TT_EMPTY)
+				{
+					item->Augment(token);
+					break;
+				}
+				else
+				{
+					parser.error_msg("Expected single number or range of numbers.",
+						PHRQ_io::OT_CONTINUE);
+				}
+			}
+		}
+
+		if (opt == 3 || opt == 4)
+		{
+			this->binList.TransferAll(cells);
+		}
+		// Process other identifiers
+		std::set < int >::iterator it;
+		switch (opt)
+		{
+		case CParser::OPT_EOF:
+			break;
+		case CParser::OPT_KEYWORD:
+			break;
+		case 3:
+		case 4:
+		case 5:
+		case 6:
+		case 7:
+		case 8:
+		case 9:
+		case 10:
+		case 11:
+		case 12:
+		case 13:
+		case 14:
+		case 15:
+		case 16:
+		case 17:
+		case 18:
+		case 19:
+		case 20:
+		case 21:
+		case 22:
+		case 23:
+		case 24:
+		case 25:
+		case 26:
+		case 27:
+			break;
+		case 0:				//file
+			std::getline(parser.get_iss(), this->file_name);
+			trim(this->file_name);
+			if (this->file_name.size() == 0)
+			{
+				this->file_name = "dump.out";
+			}
+
+			break;
+		case 1:				//append
+			{
+				parser.copy_token(token, next_char);
+				//if (!(parser.get_iss() >> this->append))
+				this->append = true;
+				if (token.c_str()[0] == 'f' || token.c_str()[0] == 'F')
+				{
+					this->append = false;
+				}
+			}
+			break;
+		case 2:			//all
+			this->SetAll(true);
+			break;
+		default:
+		case CParser::OPT_DEFAULT:
+		case CParser::OPT_ERROR:
+			opt = CParser::OPT_EOF;
+			parser.error_msg("Unknown input reading DUMP definition.",
+							 PHRQ_io::OT_CONTINUE);
+			parser.error_msg(parser.line().c_str(), PHRQ_io::OT_CONTINUE);
+			return_value = false;
+			break;
+		}
+		
+		if (opt == CParser::OPT_EOF || opt == CParser::OPT_KEYWORD)
+			break;
+	}
+	return(return_value);
+}
+
+bool dumper::Get_bool_any(void)
+{
+	return (
+		Get_bool_solution()			||
+		Get_bool_pp_assemblage()	||
+		Get_bool_exchange()			||
+		Get_bool_surface()			||
+		Get_bool_ss_assemblage()	||
+		Get_bool_gas_phase()		||
+		Get_bool_kinetics()			||
+		Get_bool_mix()				||
+		Get_bool_reaction()			||
+		Get_bool_temperature()		||
+		Get_bool_pressure()
+		);
+}
+const std::vector< std::string >::value_type temp_vopts[] = {
+	std::vector< std::string >::value_type("file"),		                // 0 
+	std::vector< std::string >::value_type("append"),		            // 1 
+	std::vector< std::string >::value_type("all"),			            // 2 
+	std::vector< std::string >::value_type("cell"),			            // 3 
+	std::vector< std::string >::value_type("cells"),		            // 4 
+	std::vector< std::string >::value_type("solution"),		            // 5 
+	std::vector< std::string >::value_type("solutions"),		        // 6 
+	std::vector< std::string >::value_type("pp_assemblage"),	        // 7 
+	std::vector< std::string >::value_type("pp_assemblages"),	        // 8 
+	std::vector< std::string >::value_type("equilibrium_phase"),	    // 9 
+	std::vector< std::string >::value_type("equilibrium_phases"),	    // 10
+	std::vector< std::string >::value_type("exchange"),		            // 11
+	std::vector< std::string >::value_type("surface"),		            // 12
+	std::vector< std::string >::value_type("ss_assemblage"),	        // 13
+	std::vector< std::string >::value_type("solid_solution"),	        // 14
+	std::vector< std::string >::value_type("solid_solutions"),	        // 15
+	std::vector< std::string >::value_type("gas_phase"),		        // 16
+	std::vector< std::string >::value_type("gas_phases"),		        // 17
+	std::vector< std::string >::value_type("kinetics"),		            // 18
+	std::vector< std::string >::value_type("mix"),			            // 19
+	std::vector< std::string >::value_type("reaction"),		            // 20
+	std::vector< std::string >::value_type("reactions"),		        // 21
+	std::vector< std::string >::value_type("temperature"),		        // 22
+	std::vector< std::string >::value_type("reaction_temperature"),	    // 23
+	std::vector< std::string >::value_type("reaction_temperatures"),    // 24
+	std::vector< std::string >::value_type("pressure"),		            // 25
+	std::vector< std::string >::value_type("reaction_pressure"),	    // 26
+	std::vector< std::string >::value_type("reaction_pressures")	    // 27
+};
+const std::vector< std::string > dumper::vopts(temp_vopts, temp_vopts + sizeof temp_vopts / sizeof temp_vopts[0]);

pyEQL/phreeqc/ext/iphreeqc-3.8.6-17100/src/phreeqcpp/dumper.h

@@ -0,0 +1,60 @@
+#if !defined(DUMPER_H_INCLUDED)
+#define DUMPER_H_INCLUDED
+#include <set>					// std::set
+#include <string>				// std::string
+#include <list>					// std::list
+#include <vector>				// std::vector
+#include "StorageBinList.h"
+class CParser;
+
+class dumper: public PHRQ_base
+{
+public:
+	dumper(PHRQ_io *io=NULL);
+	dumper(CParser & parser, PHRQ_io *io=NULL);
+	virtual ~dumper(void);
+	bool Read(CParser & parser);
+	void SetAll(bool tf);
+	std::string Get_file_name(void)		{ return(this->file_name); };
+	void Set_file_name(std::string fn)	{ this->file_name = fn; };
+	bool Get_append(void)const			{ return(this->append); };
+	void Set_append(bool app)			{ this->append = app; };
+	bool Get_bool_solution(void)		{ return(this->binList.Get_solution().Get_defined()); };
+	bool Get_bool_pp_assemblage(void)	{ return(this->binList.Get_pp_assemblage().Get_defined()); };
+	bool Get_bool_exchange(void)		{ return(this->binList.Get_exchange().Get_defined()); };
+	bool Get_bool_surface(void)			{ return(this->binList.Get_surface().Get_defined()); };
+	bool Get_bool_ss_assemblage(void)	{ return(this->binList.Get_ss_assemblage().Get_defined()); };
+	bool Get_bool_gas_phase(void)		{ return(this->binList.Get_gas_phase().Get_defined()); };
+	bool Get_bool_kinetics(void)		{ return(this->binList.Get_kinetics().Get_defined()); };
+	bool Get_bool_mix(void)				{ return(this->binList.Get_mix().Get_defined()); };
+	bool Get_bool_reaction(void)		{ return(this->binList.Get_reaction().Get_defined()); };
+	bool Get_bool_temperature(void)		{ return(this->binList.Get_temperature().Get_defined()); };
+	bool Get_bool_pressure(void)		{ return(this->binList.Get_pressure().Get_defined()); };
+	bool Get_bool_any(void);
+
+	std::set < int > & Get_solution(void)		{ return(this->binList.Get_solution().Get_numbers()); };
+	std::set < int > & Get_pp_assemblage(void)	{ return(this->binList.Get_pp_assemblage().Get_numbers()); };
+	std::set < int > & Get_exchange(void)		{ return(this->binList.Get_exchange().Get_numbers()); };
+	std::set < int > & Get_surface(void)		{ return(this->binList.Get_surface().Get_numbers()); };
+	std::set < int > & Get_ss_assemblage(void)  { return(this->binList.Get_ss_assemblage().Get_numbers()); };
+	std::set < int > & Get_gas_phase(void)		{ return(this->binList.Get_gas_phase().Get_numbers()); };
+	std::set < int > & Get_kinetics(void)		{ return(this->binList.Get_kinetics().Get_numbers()); };
+	std::set < int > & Get_mix(void)			{ return(this->binList.Get_mix().Get_numbers()); };
+	std::set < int > & Get_reaction(void)		{ return(this->binList.Get_reaction().Get_numbers()); };
+	std::set < int > & Get_temperature(void)	{ return(this->binList.Get_temperature().Get_numbers()); };
+	std::set < int > & Get_pressure(void)		{ return(this->binList.Get_pressure().Get_numbers()); };
+	bool Get_on(void)							{ return this->on; };
+	void Set_on(bool tf)						{ this->on = tf; };
+
+	StorageBinList & Get_StorageBinList(void)   { return this->binList; };
+	const StorageBinList & Get_StorageBinList(void)const   { return this->binList; };
+	void Set_StorageBinList(StorageBinList sbl) { this->binList = sbl; };
+protected:
+	std::string file_name;
+	bool append;
+	bool on;
+	StorageBinList binList;
+	const static std::vector < std::string > vopts;
+};
+
+#endif // !defined(DUMPER_H_INCLUDED)