LORENE
meos.C
1/*
2 * Methods of class MEos
3 *
4 */
5
6/*
7 * Copyright (c) 2002 Michal Bejger, Eric Gourgoulhon & Leszek Zdunik
8 *
9 * This file is part of LORENE.
10 *
11 * LORENE is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2
13 * as published by the Free Software Foundation.
14 *
15 * LORENE is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with LORENE; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 */
25
26char meos_C[] = "$Header: /cvsroot/Lorene/C++/Source/Eos/meos.C,v 1.6 2014/10/13 08:52:54 j_novak Exp $" ;
27
28/*
29 * $Id: meos.C,v 1.6 2014/10/13 08:52:54 j_novak Exp $
30 * $Log: meos.C,v $
31 * Revision 1.6 2014/10/13 08:52:54 j_novak
32 * Lorene classes and functions now belong to the namespace Lorene.
33 *
34 * Revision 1.5 2014/10/06 15:13:07 j_novak
35 * Modified #include directives to use c++ syntax.
36 *
37 * Revision 1.4 2004/04/01 11:09:26 e_gourgoulhon
38 * Copy constructor of MEos: explicit call to the default constructor of
39 * base class Eos.
40 *
41 * Revision 1.3 2002/10/16 14:36:35 j_novak
42 * Reorganization of #include instructions of standard C++, in order to
43 * use experimental version 3 of gcc.
44 *
45 * Revision 1.2 2002/04/09 14:42:29 e_gourgoulhon
46 * Dummy argument in assignment.
47 *
48 * Revision 1.1 2002/04/09 14:40:36 e_gourgoulhon
49 * Methods for new class MEos
50 *
51 *
52 *
53 * $Header: /cvsroot/Lorene/C++/Source/Eos/meos.C,v 1.6 2014/10/13 08:52:54 j_novak Exp $
54 *
55 */
56
57// C headers
58#include <cstdlib>
59
60// Lorene headers
61#include "headcpp.h"
62#include "eos.h"
63#include "utilitaires.h"
64#include "param.h"
65
66
67 //--------------------------------------//
68 // Constructors //
69 //--------------------------------------//
70
71namespace Lorene {
72MEos::MEos(int ndom_i, const Eos** mono_eos_i) : ndom(ndom_i) ,
73 constructed_from_file(false) {
74
75
76 mono_eos = new const Eos* [ndom] ;
77
78 for (int l=0; l<ndom; l++) {
79 mono_eos[l] = mono_eos_i[l] ;
80 }
81
82}
83
84
85MEos::MEos(const Eos& eos1, const Eos& eos2) : ndom(2) ,
86 constructed_from_file(false) {
87
88 mono_eos = new const Eos* [ndom] ;
89
90 mono_eos[0] = &eos1 ;
91 mono_eos[1] = &eos2 ;
92
93}
94
95MEos::MEos(const Eos& eos1, const Eos& eos2, const Eos& eos3) : ndom(3) ,
96 constructed_from_file(false) {
97
98 mono_eos = new const Eos* [ndom] ;
99
100 mono_eos[0] = &eos1 ;
101 mono_eos[1] = &eos2 ;
102 mono_eos[2] = &eos3 ;
103
104}
105
106MEos::MEos(const Eos& eos1, const Eos& eos2, const Eos& eos3, const Eos& eos4) : ndom(4) ,
107 constructed_from_file(false) {
108
109 mono_eos = new const Eos* [ndom] ;
110
111 mono_eos[0] = &eos1 ;
112 mono_eos[1] = &eos2 ;
113 mono_eos[2] = &eos3 ;
114 mono_eos[3] = &eos4 ;
115
116}
117
118// Copy constructor
119MEos::MEos(const MEos& meos) : Eos(),
120 ndom(meos.ndom),
121 constructed_from_file(false) {
122
123 mono_eos = new const Eos* [ndom] ;
124
125 for (int l=0; l<ndom; l++) {
126 mono_eos[l] = meos.mono_eos[l] ;
127 }
128
129}
130
131
132// Constructor from a binary file
133MEos::MEos(FILE* fich) : Eos(fich), constructed_from_file(true) {
134
135 fread_be(&ndom, sizeof(int), 1, fich) ;
136
137 mono_eos = new const Eos* [ndom] ;
138
139 for (int l=0; l<ndom; l++) {
140 mono_eos[l] = Eos::eos_from_file(fich) ;
141 }
142}
143
144// Constructor from a formatted file
145MEos::MEos(ifstream& fich) : Eos(fich),
146 constructed_from_file(true) {
147
148 char blabla[80] ;
149
150 fich >> ndom ; fich.getline(blabla, 80) ;
151
152 mono_eos = new const Eos* [ndom] ;
153
154 for (int l=0; l<ndom; l++) {
155 mono_eos[l] = Eos::eos_from_file(fich) ;
156 }
157}
158
159
160
161// Destructor
163
165 for (int l=0; l<ndom; l++) {
166 delete mono_eos[l] ;
167 }
168 }
169
170 delete [] mono_eos ;
171
172}
173
174 //--------------//
175 // Assignment //
176 //--------------//
177
178void MEos::operator=(const MEos& ) {
179
180 cout << "MEos::operator= : not implemented yet !" << endl ;
181 abort() ;
182
183}
184
185
186 //---------------------------------------//
187 // Outputs //
188 //---------------------------------------//
189
190void MEos::sauve(FILE* fich) const {
191
192 Eos::sauve(fich) ;
193
194 fwrite_be(&ndom, sizeof(int), 1, fich) ;
195
196 for (int l=0; l<ndom; l++) {
197 mono_eos[l]->sauve(fich) ;
198 }
199
200}
201
202ostream& MEos::operator>>(ostream & ost) const {
203
204 ost << "EOS of class MEos (multi-domain equation of state) : " << endl ;
205 ost << " Number of domains : " << ndom << endl ;
206
207 for (int l=0; l<ndom; l++) {
208 ost << "Equation of state in domain " << l << " : " << endl ;
209 ost << "-------------------------------" << endl ;
210 ost << *(mono_eos[l]) ;
211 }
212
213 return ost ;
214
215}
216
217 //------------------------//
218 // Comparison operators //
219 //------------------------//
220
221
222bool MEos::operator==(const Eos& eos_i) const {
223
224 bool resu = true ;
225
226 if ( eos_i.identify() != identify() ) {
227 cout << "The second EOS is not of type MEos !" << endl ;
228 resu = false ;
229 }
230 else{
231
232 const MEos& eos = dynamic_cast<const MEos&>( eos_i ) ;
233
234 if (eos.ndom != ndom) {
235 cout << "The two MEos have different number of domains" << endl ;
236 resu = false ;
237
238 }
239 else {
240 for (int l=0; l<ndom; l++) {
241 resu = resu && ( *(mono_eos[l]) == *(eos.mono_eos[l]) ) ;
242 }
243 }
244 }
245
246 return resu ;
247
248}
249
250bool MEos::operator!=(const Eos& eos_i) const {
251
252 return !(operator==(eos_i)) ;
253
254}
255
256
257 //------------------------------//
258 // Computational routines //
259 //------------------------------//
260
261// Baryon density from enthalpy
262//------------------------------
263
264double MEos::nbar_ent_p(double ent, const Param* par) const {
265
266 int l0 = par->get_int() ; // index of the domain
267
268 return mono_eos[l0]->nbar_ent_p(ent) ;
269
270}
271
272// Energy density from enthalpy
273//------------------------------
274
275double MEos::ener_ent_p(double ent, const Param* par) const {
276
277 int l0 = par->get_int() ; // index of the domain
278
279 return mono_eos[l0]->ener_ent_p(ent) ;
280}
281
282// Pressure from enthalpy
283//------------------------
284
285double MEos::press_ent_p(double ent, const Param* par) const {
286
287 int l0 = par->get_int() ; // index of the domain
288
289 return mono_eos[l0]->press_ent_p(ent) ;
290}
291
292// dln(n)/ln(H) from enthalpy
293//---------------------------
294
295double MEos::der_nbar_ent_p(double ent, const Param* par) const {
296
297 int l0 = par->get_int() ; // index of the domain
298
299 return mono_eos[l0]->der_nbar_ent_p(ent) ;
300}
301
302// dln(e)/ln(H) from enthalpy
303//---------------------------
304
305double MEos::der_ener_ent_p(double ent, const Param* par) const {
306
307 int l0 = par->get_int() ; // index of the domain
308
309 return mono_eos[l0]->der_ener_ent_p(ent) ;
310}
311
312// dln(p)/ln(H) from enthalpy
313//---------------------------
314
315double MEos::der_press_ent_p(double ent, const Param* par) const {
316
317 int l0 = par->get_int() ; // index of the domain
318
319 return mono_eos[l0]->der_press_ent_p(ent) ;
320}
321
322
323
324}
Equation of state base class.
Definition eos.h:190
virtual int identify() const =0
Returns a number to identify the sub-classe of Eos the object belongs to.
static Eos * eos_from_file(FILE *)
Construction of an EOS from a binary file.
virtual double press_ent_p(double ent, const Param *par=0x0) const =0
Computes the pressure from the log-enthalpy and extra parameters (virtual function implemented in the...
virtual double der_press_ent_p(double ent, const Param *par=0x0) const =0
Computes the logarithmic derivative from the log-enthalpy and extra parameters (virtual function imp...
virtual void sauve(FILE *) const
Save in a file.
Definition eos.C:179
virtual double der_ener_ent_p(double ent, const Param *par=0x0) const =0
Computes the logarithmic derivative from the log-enthalpy with extra parameters (virtual function im...
virtual double der_nbar_ent_p(double ent, const Param *par=0x0) const =0
Computes the logarithmic derivative from the log-enthalpy and extra parameters (virtual function imp...
virtual double ener_ent_p(double ent, const Param *par=0x0) const =0
Computes the total energy density from the log-enthalpy and extra parameters (virtual function implem...
virtual double nbar_ent_p(double ent, const Param *par=0x0) const =0
Computes the baryon density from the log-enthalpy and extra parameters (virtual function implemented ...
EOS with domain dependency.
Definition eos.h:2279
virtual int identify() const
Returns a number to identify the sub-classe of Eos the object belongs to.
virtual ostream & operator>>(ostream &) const
Operator >>
Definition meos.C:202
virtual ~MEos()
Destructor.
Definition meos.C:162
void operator=(const MEos &)
Assignment to another MEos.
Definition meos.C:178
virtual double ener_ent_p(double ent, const Param *par=0x0) const
Computes the total energy density from the log-enthalpy.
Definition meos.C:275
MEos(int ndom_i, const Eos **mono_eos_i)
Standard constructor.
Definition meos.C:72
virtual double nbar_ent_p(double ent, const Param *par=0x0) const
Computes the baryon density from the log-enthalpy.
Definition meos.C:264
virtual double der_press_ent_p(double ent, const Param *par=0x0) const
Computes the logarithmic derivative from the log-enthalpy.
Definition meos.C:315
virtual void sauve(FILE *) const
Save in a file.
Definition meos.C:190
virtual double der_ener_ent_p(double ent, const Param *par=0x0) const
Computes the logarithmic derivative from the log-enthalpy.
Definition meos.C:305
virtual double der_nbar_ent_p(double ent, const Param *par=0x0) const
Computes the logarithmic derivative from the log-enthalpy.
Definition meos.C:295
virtual bool operator==(const Eos &) const
Comparison operator (egality)
Definition meos.C:222
virtual double press_ent_p(double ent, const Param *par=0x0) const
Computes the pressure from the log-enthalpy.
Definition meos.C:285
bool constructed_from_file
Indicates wether the EOS has been constructed from a file.
Definition eos.h:2292
const Eos ** mono_eos
Array (upon the domains) containing the various EOS.
Definition eos.h:2286
int ndom
Number of domains.
Definition eos.h:2289
virtual bool operator!=(const Eos &) const
Comparison operator (difference)
Definition meos.C:250
Parameter storage.
Definition param.h:125
const int & get_int(int position=0) const
Returns the reference of a int stored in the list.
Definition param.C:292
int fread_be(int *aa, int size, int nb, FILE *fich)
Reads integer(s) from a binary file according to the big endian convention.
Definition fread_be.C:69
int fwrite_be(const int *aa, int size, int nb, FILE *fich)
Writes integer(s) into a binary file according to the big endian convention.
Definition fwrite_be.C:70
Lorene prototypes.
Definition app_hor.h:64