changa 3.5
Loading...
Searching...
No Matches
InOutput.h
Go to the documentation of this file.
1
3#ifndef __INOUTPUT_H
4#define __INOUTPUT_H
5
6class OutputParams;
7#include "DataManager.h"
8
9int64_t ncGetCount(std::string typedir);
10
16class OutputParams : public PUP::able
17{
18 public:
20 virtual double dValue(GravityParticle *p) = 0;
22 virtual Vector3D<double> vValue(GravityParticle *p) = 0;
24 virtual void setDValue(GravityParticle *p, double d) = 0;
26 virtual void setVValue(GravityParticle *p, Vector3D<double> v) {
27 CkAbort("Undefined read of vector");
28 }
29
30 virtual int64_t iValue(GravityParticle *p) = 0;
32 virtual void setIValue(GravityParticle *p, int64_t iValue) = 0;
33 int bFloat;
34 int bVector;
35 int iBinaryOut;
36 double dTime;
37 std::string fileName;
38 std::string sTipsyExt;
39 std::string sNChilExt;
40 unsigned int iType;
41 unsigned int iTypeWriting;
42 DataManager *dm;
43
44 OutputParams() {dm = NULL;}
45 PUPable_abstract(OutputParams);
46 OutputParams(CkMigrateMessage *m) : PUP::able(m) {dm = NULL;}
47 virtual void pup(PUP::er &p) {
48 PUP::able::pup(p);//Call base class
49 p|fileName;
50 p|sTipsyExt;
51 p|sNChilExt;
52 p|bFloat;
53 p|bVector;
54 p|iBinaryOut;
55 p|dTime;
56 p|iType;
57 p|iTypeWriting;
58 }
59 };
60
61#ifdef SUPERBUBBLE
63class uHotOutputParams : public OutputParams
64{
65 public:
66 virtual double dValue(GravityParticle *p) {return (p->isGas() ? p->uHot() : 0);}
67 virtual Vector3D<double> vValue(GravityParticle *p)
68 {CkAssert(0); return 0.0;}
69 virtual void setDValue(GravityParticle *p, double val) {
70 if(p->isGas())
71 p->uHot() = val;
72 }
73 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
74 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
75 uHotOutputParams() {}
76 uHotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
77 bFloat = 1; bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
78 sTipsyExt = "uHot"; sNChilExt = "uHot";
79 dTime = _dTime;
80 iType = TYPE_GAS; }
81 PUPable_decl(uHotOutputParams);
82 uHotOutputParams(CkMigrateMessage *m) {}
83 virtual void pup(PUP::er &p) {
84 OutputParams::pup(p);//Call base class
85 }
86 };
88class uOutputParams : public OutputParams
89{
90 public:
91 virtual double dValue(GravityParticle *p) {return (p->isGas() ? p->u() : 0);}
92 virtual Vector3D<double> vValue(GravityParticle *p)
93 {CkAssert(0); return 0.0;}
94 virtual void setDValue(GravityParticle *p, double val) {
95 if(p->isGas())
96 p->u() = val;
97 }
98 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
99 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
100 uOutputParams() {}
101 uOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
102 bFloat = 1; bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
103 sTipsyExt = "u"; sNChilExt = "u";
104 dTime = _dTime;
105 iType = TYPE_GAS; }
106 PUPable_decl(uOutputParams);
107 uOutputParams(CkMigrateMessage *m) {}
108 virtual void pup(PUP::er &p) {
109 OutputParams::pup(p);//Call base class
110 }
111 };
112
114class MassHotOutputParams : public OutputParams
115{
116 public:
117 virtual double dValue(GravityParticle *p) {return (p->isGas() ? p->massHot() : 0);}
118 virtual Vector3D<double> vValue(GravityParticle *p)
119 {CkAssert(0); return 0.0;}
120 virtual void setDValue(GravityParticle *p, double val) {
121 if (p->isGas())
122 p->massHot() = val;
123 }
124 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
125 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
126 MassHotOutputParams() {}
127 MassHotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
128 bFloat = 1;
129 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
130 sTipsyExt = "massHot"; sNChilExt = "massHot";
131 dTime = _dTime;
132 iType = TYPE_GAS; }
133 PUPable_decl(MassHotOutputParams);
134 MassHotOutputParams(CkMigrateMessage *m) {}
135 virtual void pup(PUP::er &p) {
136 OutputParams::pup(p);//Call base class
137 }
138 };
139
141class TempEffOutputParams : public OutputParams
142{
143 public:
144 double duTFac;
145 bool bGasCooling;
146 virtual double dValue(GravityParticle *p) {
147 if (!TYPETest(p, TYPE_GAS)) return 0.0;
148 if(bGasCooling) {
149 double x = p->massHot()/p->mass;
150#ifndef COOLING_NONE
151 return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
152 x*p->uHot()+(1-x)*p->u(),
153#ifdef COOLING_GRACKLE
154 p->fDensity,
155#endif
156 p->fMetals());
157#else
158 CkAssert(0);
159#endif
160 }
161 return duTFac*p->u();
162 }
163 virtual Vector3D<double> vValue(GravityParticle *p)
164 {CkAssert(0); return 0.0;}
165 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
166 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
167 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
168 TempEffOutputParams() {}
169 TempEffOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
170 bool _bGasCooling, double _duTFac) {
171 bFloat = 1; bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
172 sTipsyExt = "tempEff"; sNChilExt = "temperatureEff";
173 dTime = _dTime; bGasCooling = _bGasCooling; duTFac = _duTFac;
174 iType = TYPE_GAS; }
175 PUPable_decl(TempEffOutputParams);
176 TempEffOutputParams(CkMigrateMessage *m) {}
177 virtual void pup(PUP::er &p) {
178 OutputParams::pup(p);//Call base class
179 p|bGasCooling;
180 p|duTFac;
181 }
182 };
183#endif
185class MassOutputParams : public OutputParams
186{
187 public:
188 virtual double dValue(GravityParticle *p) {return p->mass;}
189 virtual Vector3D<double> vValue(GravityParticle *p)
190 {CkAssert(0); return 0.0;}
191 virtual void setDValue(GravityParticle *p, double val) {p->mass = val;}
192 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
193 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
194 MassOutputParams() {}
195 MassOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
196 bFloat = 1;
197 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
198 sTipsyExt = "mass"; sNChilExt = "mass";
199 dTime = _dTime;
200 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
201 PUPable_decl(MassOutputParams);
202 MassOutputParams(CkMigrateMessage *m) {}
203 virtual void pup(PUP::er &p) {
204 OutputParams::pup(p);//Call base class
205 }
206 };
207
209class PosOutputParams : public OutputParams
210{
211 public:
212 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
213 virtual Vector3D<double> vValue(GravityParticle *p)
214 {return p->position;}
215 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
216 virtual void setVValue(GravityParticle *p, Vector3D<double> val)
217 {p->position = val;}
218 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
219 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
220 PosOutputParams() {}
221 PosOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
222 bFloat = 1;
223 bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
224 sTipsyExt = "pos"; sNChilExt = "pos";
225 dTime = _dTime;
226 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
227 PUPable_decl(PosOutputParams);
228 PosOutputParams(CkMigrateMessage *m) {}
229 virtual void pup(PUP::er &p) {
230 OutputParams::pup(p);//Call base class
231 }
232 };
233
235class VelOutputParams : public OutputParams
236{
237 public:
238 double dVFac;
239 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
240 virtual Vector3D<double> vValue(GravityParticle *p)
241 {return dVFac*p->velocity;}
242 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
243 virtual void setVValue(GravityParticle *p, Vector3D<double> val)
244 {p->velocity = val/dVFac;}
245 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
246 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
247 VelOutputParams() {}
248 VelOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
249 double _dVFac) {
250 bFloat = 1;
251 bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
252 sTipsyExt = "vel"; sNChilExt = "vel";
253 dTime = _dTime; dVFac = _dVFac;
254 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
255 PUPable_decl(VelOutputParams);
256 VelOutputParams(CkMigrateMessage *m) {}
257 virtual void pup(PUP::er &p) {
258 OutputParams::pup(p);//Call base class
259 p|dVFac;
260 }
261 };
262
264class PotOutputParams : public OutputParams
265{
266 public:
267 virtual double dValue(GravityParticle *p) {return p->potential;}
268 virtual Vector3D<double> vValue(GravityParticle *p)
269 {CkAssert(0); return 0.0;}
270 virtual void setDValue(GravityParticle *p, double val) {p->potential = val;}
271 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
272 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
273 PotOutputParams() {}
274 PotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
275 bFloat = 1;
276 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
277 sTipsyExt = "pot"; sNChilExt = "pot";
278 dTime = _dTime;
279 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
280 PUPable_decl(PotOutputParams);
281 PotOutputParams(CkMigrateMessage *m) {}
282 virtual void pup(PUP::er &p) {
283 OutputParams::pup(p);//Call base class
284 }
285 };
286
287
288#ifdef COLLISION
290class SpinOutputParams : public OutputParams
291{
292public:
293 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
294 virtual Vector3D<double> vValue(GravityParticle *p)
295 {return p->w;}
296 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
297 virtual void setVValue(GravityParticle *p, Vector3D<double> val)
298 {p->position = val;}
299 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
300 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
301 SpinOutputParams() {}
302 SpinOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
303 bFloat = 1;
304 bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
305 sTipsyExt = "spin"; sNChilExt = "spin";
306 dTime = _dTime;
307 iType = TYPE_DARK; }
308 PUPable_decl(SpinOutputParams);
309 SpinOutputParams(CkMigrateMessage *m) {}
310 virtual void pup(PUP::er &p) {
311 OutputParams::pup(p);//Call base class
312 }
313 };
314#endif
315
317class GasDenOutputParams : public OutputParams
318{
319 public:
320 virtual double dValue(GravityParticle *p) {return p->fDensity;}
321 virtual Vector3D<double> vValue(GravityParticle *p)
322 {CkAssert(0); return 0.0;}
323 virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
324 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
325 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
326 GasDenOutputParams() {}
327 GasDenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
328 bFloat = 1;
329 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
330 sTipsyExt = "gasden"; sNChilExt = "GasDensity";
331 dTime = _dTime;
332 iType = TYPE_GAS; }
333 PUPable_decl(GasDenOutputParams);
334 GasDenOutputParams(CkMigrateMessage *m) {}
335 virtual void pup(PUP::er &p) {
336 OutputParams::pup(p);//Call base class
337 }
338 };
339
341class TempOutputParams : public OutputParams
342{
343 public:
344 double duTFac;
345 bool bGasCooling;
346 virtual double dValue(GravityParticle *p) {
347 if(bGasCooling) {
348#ifndef COOLING_NONE
349#ifdef COOLING_GRACKLE
350 return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
351 p->u(), p->fDensity, p->fMetals());
352#else
353 return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
354 p->u(), p->fMetals());
355#endif
356#else
357 CkAssert(0);
358#endif
359 }
360 return duTFac*p->u();
361 }
362 virtual Vector3D<double> vValue(GravityParticle *p)
363 {CkAssert(0); return 0.0;}
364 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
365 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
366 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
367 TempOutputParams() {}
368 TempOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
369 bool _bGasCooling, double _duTFac) {
370 bFloat = 1;
371 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
372 sTipsyExt = "temp"; sNChilExt = "temperature";
373 dTime = _dTime; bGasCooling = _bGasCooling; duTFac = _duTFac;
374 iType = TYPE_GAS; }
375 PUPable_decl(TempOutputParams);
376 TempOutputParams(CkMigrateMessage *m) {}
377 virtual void pup(PUP::er &p) {
378 OutputParams::pup(p);//Call base class
379 p|bGasCooling;
380 p|duTFac;
381 }
382 };
383
384
386class AccOutputParams : public OutputParams
387{
388 public:
389 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
390 virtual Vector3D<double> vValue(GravityParticle *p)
391 {return p->treeAcceleration;}
392 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
393 virtual void setVValue(GravityParticle *p, Vector3D<double> val)
394 {p->treeAcceleration = val;}
395 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
396 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
397 AccOutputParams() {}
398 AccOutputParams(std::string _fileName) { bFloat = 1; bVector = 1; fileName = _fileName;}
399 AccOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
400 bFloat = 1;
401 bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
402 sTipsyExt = "acc2"; sNChilExt = "acc";
403 dTime = _dTime;
404 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
405 PUPable_decl(AccOutputParams);
406 AccOutputParams(CkMigrateMessage *m) {}
407 virtual void pup(PUP::er &p) {
408 OutputParams::pup(p);//Call base class
409 }
410 };
411
413class DenOutputParams : public OutputParams
414{
415 virtual double dValue(GravityParticle *p) {return p->fDensity;}
416 virtual Vector3D<double> vValue(GravityParticle *p)
417 {CkAssert(0); return 0.0;}
418 virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
419 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
420 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
421 public:
422 DenOutputParams() {}
423 DenOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
424 DenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
425 bFloat = 1;
426 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
427 sTipsyExt = "den"; sNChilExt = "den";
428 dTime = _dTime;
429 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
430 PUPable_decl(DenOutputParams);
431 DenOutputParams(CkMigrateMessage *m) {}
432 virtual void pup(PUP::er &p) {
433 OutputParams::pup(p);//Call base class
434 }
435 };
436
438class HsmOutputParams : public OutputParams
439{
440 virtual double dValue(GravityParticle *p) {return 0.5*p->fBall;}
441 virtual Vector3D<double> vValue(GravityParticle *p)
442 {CkAssert(0); return 0.0;}
443 virtual void setDValue(GravityParticle *p, double val) {p->fBall = 2.0*val;}
444 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
445 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
446 public:
447 HsmOutputParams() {}
448 HsmOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
449 bFloat = 1;
450 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
451 sTipsyExt = "smoothlength"; sNChilExt = "smoothlength";
452 dTime = _dTime;
453 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
454 PUPable_decl(HsmOutputParams);
455 HsmOutputParams(CkMigrateMessage *m) {}
456 virtual void pup(PUP::er &p) {
457 OutputParams::pup(p);//Call base class
458 }
459 };
460
462class SoftOutputParams : public OutputParams
463{
464 public:
465 virtual double dValue(GravityParticle *p) {
466#ifdef CHANGESOFT
467 return p->fSoft0;
468#else
469 return p->soft;
470#endif
471 }
472 virtual Vector3D<double> vValue(GravityParticle *p)
473 {CkAssert(0); return 0.0;}
474 virtual void setDValue(GravityParticle *p, double val) {
475#ifdef CHANGESOFT
476 p->fSoft0 = val;
477#else
478 p->soft = val;
479#endif
480 }
481 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
482 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
483 SoftOutputParams() {}
484 SoftOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
485 bFloat = 1;
486 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
487 sTipsyExt = "soft"; sNChilExt = "soft";
488 dTime = _dTime;
489 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
490 PUPable_decl(SoftOutputParams);
491 SoftOutputParams(CkMigrateMessage *m) {}
492 virtual void pup(PUP::er &p) {
493 OutputParams::pup(p);//Call base class
494 }
495 };
496
498class PresOutputParams : public OutputParams
499{
500 virtual double dValue(GravityParticle *p)
501 {
502 if (TYPETest(p, TYPE_GAS))
503 return p->fDensity*p->fDensity*p->PoverRho2();
504 else
505 return 0.0;
506 }
507 virtual Vector3D<double> vValue(GravityParticle *p)
508 {CkAssert(0); return 0.0;}
509 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
510 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
511 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
512 public:
513 PresOutputParams() {}
514 PresOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
515 PresOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
516 bFloat = 1;
517 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
518 sTipsyExt = "pres"; sNChilExt = "pres";
519 dTime = _dTime;
520 iType = TYPE_GAS; }
521 PUPable_decl(PresOutputParams);
522 PresOutputParams(CkMigrateMessage *m) {}
523 virtual void pup(PUP::er &p) {
524 OutputParams::pup(p);//Call base class
525 }
526 };
527
529class AlphaOutputParams : public OutputParams
530{
531 virtual double dValue(GravityParticle *p)
532 {
533#ifdef CULLENALPHA
534 if (p->isGas())
535 return p->CullenAlpha();
536 else
537#endif /* CULLENALPHA */
538 return 0.0;
539 }
540 virtual Vector3D<double> vValue(GravityParticle *p)
541 {CkAssert(0); return 0.0;}
542 virtual void setDValue(GravityParticle *p, double val) {
543#ifdef CULLENALPHA
544 if(p->isGas())
545 p->CullenAlpha() = val;
546#endif
547 }
548 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
549 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
550 public:
551 AlphaOutputParams() {}
552 AlphaOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
553 AlphaOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
554 bFloat = 1;
555 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
556 sTipsyExt = "alpha"; sNChilExt = "alpha";
557 dTime = _dTime;
558 iType = TYPE_GAS; }
559 PUPable_decl(AlphaOutputParams);
560 AlphaOutputParams(CkMigrateMessage *m) {}
561 virtual void pup(PUP::er &p) {
562 OutputParams::pup(p);//Call base class
563 }
564};
565
567class DvDsOutputParams : public OutputParams
568{
569 virtual double dValue(GravityParticle *p)
570 {
571#ifdef CULLENALPHA
572 if (TYPETest(p, TYPE_GAS))
573 return p->dvds();
574 else
575#endif /* CULLENALPHA */
576 return 0.0;
577 }
578 virtual Vector3D<double> vValue(GravityParticle *p)
579 {CkAssert(0); return 0.0;}
580 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
581 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
582 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
583 public:
584 DvDsOutputParams() {}
585 DvDsOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
586 DvDsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
587 bFloat = 1;
588 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
589 sTipsyExt = "dvds"; sNChilExt = "dvds";
590 dTime = _dTime;
591 iType = TYPE_GAS; }
592 PUPable_decl(DvDsOutputParams);
593 DvDsOutputParams(CkMigrateMessage *m) {}
594 virtual void pup(PUP::er &p) {
595 OutputParams::pup(p); //Call base class
596 }
597};
598
599
601class DivVOutputParams : public OutputParams
602{
603 virtual double dValue(GravityParticle *p)
604 {
605 if (TYPETest(p, TYPE_GAS))
606 return p->divv();
607 else
608 return 0.0;
609 }
610 virtual Vector3D<double> vValue(GravityParticle *p)
611 {CkAssert(0); return 0.0;}
612 virtual void setDValue(GravityParticle *p, double val) {p->divv() = val;}
613 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
614 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
615 public:
616 DivVOutputParams() {}
617 DivVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
618 bFloat = 1;
619 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
620 sTipsyExt = "divv"; sNChilExt = "divv";
621 dTime = _dTime;
622 iType = TYPE_GAS; }
623 PUPable_decl(DivVOutputParams);
624 DivVOutputParams(CkMigrateMessage *m) {}
625 virtual void pup(PUP::er &p) {
626 OutputParams::pup(p);//Call base class
627 }
628 };
629
631class PDVOutputParams : public OutputParams
632{
633 virtual double dValue(GravityParticle *p)
634 {
635 if (TYPETest(p, TYPE_GAS))
636 return p->PdV();
637 else
638 return 0.0;
639 }
640 virtual Vector3D<double> vValue(GravityParticle *p)
641 {CkAssert(0); return 0.0;}
642 virtual void setDValue(GravityParticle *p, double val) {p->PdV() = val;}
643 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
644 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
645 public:
646 PDVOutputParams() {}
647 PDVOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
648 PDVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
649 bFloat = 1;
650 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
651 sTipsyExt = "PdV"; sNChilExt = "PdV";
652 dTime = _dTime;
653 iType = TYPE_GAS; }
654 PUPable_decl(PDVOutputParams);
655 PDVOutputParams(CkMigrateMessage *m) {}
656 virtual void pup(PUP::er &p) {
657 OutputParams::pup(p);//Call base class
658 }
659 };
660
662class MuMaxOutputParams : public OutputParams
663{
664 virtual double dValue(GravityParticle *p)
665 {
666 if (TYPETest(p, TYPE_GAS))
667 return p->mumax();
668 else
669 return 0.0;
670 }
671 virtual Vector3D<double> vValue(GravityParticle *p)
672 {CkAssert(0); return 0.0;}
673 virtual void setDValue(GravityParticle *p, double val) {p->mumax() = val;}
674 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
675 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
676 public:
677 MuMaxOutputParams() {}
678 MuMaxOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
679 MuMaxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
680 bFloat = 1;
681 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
682 sTipsyExt = "mumax"; sNChilExt = "mumax";
683 dTime = _dTime;
684 iType = TYPE_GAS; }
685 PUPable_decl(MuMaxOutputParams);
686 MuMaxOutputParams(CkMigrateMessage *m) {}
687 virtual void pup(PUP::er &p) {
688 OutputParams::pup(p);//Call base class
689 }
690 };
691
693class BSwOutputParams : public OutputParams
694{
695 virtual double dValue(GravityParticle *p)
696 {
697 if (TYPETest(p, TYPE_GAS))
698 return p->BalsaraSwitch();
699 else
700 return 0.0;
701 }
702 virtual Vector3D<double> vValue(GravityParticle *p)
703 {CkAssert(0); return 0.0;}
704 virtual void setDValue(GravityParticle *p, double val) {p->BalsaraSwitch() = val;}
705 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
706 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
707 public:
708 BSwOutputParams() {}
709 BSwOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
710 bFloat = 1;
711 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
712 sTipsyExt = "BSw"; sNChilExt = "BSw";
713 dTime = _dTime;
714 iType = TYPE_GAS; }
715 PUPable_decl(BSwOutputParams);
716 BSwOutputParams(CkMigrateMessage *m) {}
717 virtual void pup(PUP::er &p) {
718 OutputParams::pup(p);//Call base class
719 }
720 };
721
723class CsOutputParams : public OutputParams
724{
725 virtual double dValue(GravityParticle *p)
726 {
727 if (TYPETest(p, TYPE_GAS))
728 return p->c();
729 else
730 return 0.0;
731 }
732 virtual Vector3D<double> vValue(GravityParticle *p)
733 {CkAssert(0); return 0.0;}
734 virtual void setDValue(GravityParticle *p, double val) {p->c() = val;}
735 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
736 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
737 public:
738 CsOutputParams() {}
739 CsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
740 bFloat = 1;
741 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
742 sTipsyExt = "c"; sNChilExt = "c";
743 dTime = _dTime;
744 iType = TYPE_GAS; }
745 PUPable_decl(CsOutputParams);
746 CsOutputParams(CkMigrateMessage *m) {}
747 virtual void pup(PUP::er &p) {
748 OutputParams::pup(p);//Call base class
749 }
750 };
751
753class EDotOutputParams : public OutputParams
754{
755 virtual double dValue(GravityParticle *p)
756 {
757#ifndef COOLING_NONE
758 CkAssert(dm != NULL);
759 if (TYPETest(p, TYPE_GAS)) {
760 double r[3]; // For conversion to C
761 p->position.array_form(r);
762#ifdef COOLING_MOLECULARH
763 return (COOL_EDOT(dm->Cool, &p->CoolParticle(), p->u(), p->fDensity, p->fMetals(), r, sqrt(0.25)*(p->fBall)));
764#else
765 return (COOL_EDOT(dm->Cool, &p->CoolParticle(), p->u(), p->fDensity, p->fMetals(), r));
766#endif
767 }
768 else
769#endif
770 return 0.0;
771 }
772 virtual Vector3D<double> vValue(GravityParticle *p)
773 {CkAssert(0); return 0.0;}
774 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
775 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
776 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
777 public:
778 EDotOutputParams() {}
779 EDotOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
780 EDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
781 bFloat = 1;
782 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
783 sTipsyExt = "eDot"; sNChilExt = "eDot";
784 dTime = _dTime;
785 iType = TYPE_GAS; }
786 PUPable_decl(EDotOutputParams);
787 EDotOutputParams(CkMigrateMessage *m) {}
788 virtual void pup(PUP::er &p) {
789 OutputParams::pup(p);//Call base class
790 }
791 };
792
794class Cool0OutputParams : public OutputParams
795{
796 virtual double dValue(GravityParticle *p)
797 {
798#ifndef COOLING_NONE
799 CkAssert(dm != NULL);
800 if (TYPETest(p, TYPE_GAS))
801 return COOL_ARRAY0(dm->Cool, &p->CoolParticle(), p->fMetals());
802 else
803#endif
804 return 0.0;
805 }
806 virtual Vector3D<double> vValue(GravityParticle *p)
807 {CkAssert(0); return 0.0;}
808 virtual void setDValue(GravityParticle *p, double val) {
809#ifndef COOLING_NONE
810 if (TYPETest(p, TYPE_GAS))
811 COOL_SET_ARRAY0(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
812#endif
813 }
814 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
815 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
816 public:
817 Cool0OutputParams() {}
818 Cool0OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
819 bFloat = 1;
820 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
821#ifndef COOLING_NONE
822 sTipsyExt = COOL_ARRAY0_EXT; sNChilExt = COOL_ARRAY0_EXT;
823#endif
824 dTime = _dTime;
825 iType = TYPE_GAS; }
826 PUPable_decl(Cool0OutputParams);
827 Cool0OutputParams(CkMigrateMessage *m) {}
828 virtual void pup(PUP::er &p) {
829 OutputParams::pup(p);//Call base class
830 }
831 };
832
834class Cool1OutputParams : public OutputParams
835{
836 virtual double dValue(GravityParticle *p)
837 {
838#ifndef COOLING_NONE
839 CkAssert(dm != NULL);
840 if (TYPETest(p, TYPE_GAS))
841 return COOL_ARRAY1(dm->Cool, &p->CoolParticle(), p->fMetals());
842 else
843#endif
844 return 0.0;
845 }
846 virtual Vector3D<double> vValue(GravityParticle *p)
847 {CkAssert(0); return 0.0;}
848 virtual void setDValue(GravityParticle *p, double val) {
849#ifndef COOLING_NONE
850 //XXX be sure metals has been set!
851 if (TYPETest(p, TYPE_GAS))
852 COOL_SET_ARRAY1(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
853#endif
854 }
855 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
856 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
857 public:
858 Cool1OutputParams() {}
859 Cool1OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
860 bFloat = 1;
861 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
862#ifndef COOLING_NONE
863 sTipsyExt = COOL_ARRAY1_EXT; sNChilExt = COOL_ARRAY1_EXT;
864#endif
865 dTime = _dTime;
866 iType = TYPE_GAS; }
867 PUPable_decl(Cool1OutputParams);
868 Cool1OutputParams(CkMigrateMessage *m) {}
869 virtual void pup(PUP::er &p) {
870 OutputParams::pup(p);//Call base class
871 }
872 };
873
875class Cool2OutputParams : public OutputParams
876{
877 virtual double dValue(GravityParticle *p)
878 {
879#ifndef COOLING_NONE
880 CkAssert(dm != NULL);
881 if (TYPETest(p, TYPE_GAS))
882 return COOL_ARRAY2(dm->Cool, &p->CoolParticle(), p->fMetals());
883 else
884#endif
885 return 0.0;
886 }
887 virtual Vector3D<double> vValue(GravityParticle *p)
888 {CkAssert(0); return 0.0;}
889 virtual void setDValue(GravityParticle *p, double val) {
890#ifndef COOLING_NONE
891 if (TYPETest(p, TYPE_GAS))
892 COOL_SET_ARRAY2(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
893#endif
894 }
895 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
896 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
897 public:
898 Cool2OutputParams() {}
899 Cool2OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
900 bFloat = 1;
901 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
902#ifndef COOLING_NONE
903 sTipsyExt = COOL_ARRAY2_EXT; sNChilExt = COOL_ARRAY2_EXT;
904#endif
905 dTime = _dTime;
906 iType = TYPE_GAS; }
907 PUPable_decl(Cool2OutputParams);
908 Cool2OutputParams(CkMigrateMessage *m) {}
909 virtual void pup(PUP::er &p) {
910 OutputParams::pup(p);//Call base class
911 }
912 };
913
914
916class Cool3OutputParams : public OutputParams
917{
918 virtual double dValue(GravityParticle *p)
919 {
920#ifndef COOLING_NONE
921#ifdef COOLING_MOLECULARH
922 CkAssert(dm != NULL);
923 if (TYPETest(p, TYPE_GAS))
924 return COOL_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals());
925 else
926#else /*COOLING_MOLECULARH*/
927 if (TYPETest(p, TYPE_GAS))
928 return COOL_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals());
929 else
930#endif /*COOLING_MOLECULARH*/
931#endif /*COOLING_NONE*/
932 return 0.0;
933 }
934 virtual Vector3D<double> vValue(GravityParticle *p)
935 {CkAssert(0); return 0.0;}
936 virtual void setDValue(GravityParticle *p, double val) {
937#ifndef COOLING_NONE
938 if (TYPETest(p, TYPE_GAS))
939#ifdef COOLING_MOLECULARH
940 COOL_SET_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
941#else /*COOLING_MOLECULARH*/
942 CkAssert(0);
943#endif /*COOLING_MOLECULARH*/
944#endif /*COOLING_NONE*/
945 }
946 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
947 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
948 public:
949 Cool3OutputParams() {}
950 Cool3OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
951 bFloat = 1;
952 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
953#ifndef COOLING_NONE
954 sTipsyExt = COOL_ARRAY3_EXT; sNChilExt = COOL_ARRAY3_EXT;
955#endif
956 dTime = _dTime;
957 iType = TYPE_GAS; }
958 PUPable_decl(Cool3OutputParams);
959 Cool3OutputParams(CkMigrateMessage *m) {}
960 virtual void pup(PUP::er &p) {
961 OutputParams::pup(p);//Call base class
962 }
963};
964
965#ifdef COOLING_MOLECULARH
966class LWOutputParams : public OutputParams
967{
968 virtual double dValue(GravityParticle *p) {
969 if (TYPETest(p, TYPE_STAR)) return p->dStarLymanWerner();
970 if (TYPETest(p, TYPE_GAS)) return p->CoolParticle().dLymanWerner;
971 else return 0.0;
972 }
973 virtual Vector3D<double> vValue(GravityParticle *p)
974 {CkAssert(0); return 0.0;}
975 virtual void setDValue(GravityParticle *p, double val) {
976 if (TYPETest(p, TYPE_STAR)) p->dStarLymanWerner() = val;
977 if (TYPETest(p, TYPE_GAS)) p->CoolParticle().dLymanWerner = val;
978 }
979 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
980 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
981 public:
982 LWOutputParams() {}
983 LWOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
984 bFloat = 1;
985 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
986 sTipsyExt = "lw"; sNChilExt = "lw";
987 dTime = _dTime;
988 iType = TYPE_GAS | TYPE_STAR; }
989 PUPable_decl(LWOutputParams);
990 LWOutputParams(CkMigrateMessage *m) {}
991 virtual void pup(PUP::er &p) {
992 OutputParams::pup(p);//Call base class
993 }
994 };
995
996#ifdef SHIELDSF
997class ShieldOutputParams : public OutputParams
998{
999 virtual double dValue(GravityParticle *p) {
1000 if (TYPETest(p, TYPE_STAR)) return p->fShieldForm();
1001 else return 0.0;
1002 }
1003 virtual Vector3D<double> vValue(GravityParticle *p)
1004 {CkAssert(0); return 0.0;}
1005 virtual void setDValue(GravityParticle *p, double val) {
1006 if (TYPETest(p, TYPE_STAR)) p->fShieldForm() = val;
1007 }
1008 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1009 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1010 public:
1011 ShieldOutputParams() {}
1012 ShieldOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1013 bFloat = 1;
1014 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1015 sTipsyExt = "shieldform"; sNChilExt = "shieldform";
1016 dTime = _dTime;
1017 iType = TYPE_STAR; }
1018 PUPable_decl(ShieldOutputParams);
1019 ShieldOutputParams(CkMigrateMessage *m) {}
1020 virtual void pup(PUP::er &p) {
1021 OutputParams::pup(p);//Call base class
1022 }
1023};
1024#endif
1025
1026
1027#endif /*COOLING_MOLECULARH*/
1028
1030class OxOutputParams : public OutputParams
1031{
1032 virtual double dValue(GravityParticle *p) {
1033 if (TYPETest(p, TYPE_STAR)) return p->fStarMFracOxygen();
1034 if (TYPETest(p, TYPE_GAS)) return p->fMFracOxygen();
1035 else return 0.0;
1036 }
1037 virtual Vector3D<double> vValue(GravityParticle *p)
1038 {CkAssert(0); return 0.0;}
1039 virtual void setDValue(GravityParticle *p, double val) {
1040 if (TYPETest(p, TYPE_STAR)) p->fStarMFracOxygen() = val;
1041 if (TYPETest(p, TYPE_GAS)) p->fMFracOxygen() = val;
1042 }
1043 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1044 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1045 public:
1046 OxOutputParams() {}
1047 OxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1048 bFloat = 1;
1049 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1050 sTipsyExt = "OxMassFrac"; sNChilExt = "OxMassFrac";
1051 dTime = _dTime;
1052 iType = TYPE_GAS | TYPE_STAR; }
1053 PUPable_decl(OxOutputParams);
1054 OxOutputParams(CkMigrateMessage *m) {}
1055 virtual void pup(PUP::er &p) {
1056 OutputParams::pup(p);//Call base class
1057 }
1058 };
1059
1061class FeOutputParams : public OutputParams
1062{
1063 virtual double dValue(GravityParticle *p) {
1064 if (TYPETest(p, TYPE_STAR)) return p->fStarMFracIron();
1065 if (TYPETest(p, TYPE_GAS)) return p->fMFracIron();
1066 else return 0.0;
1067 }
1068 virtual Vector3D<double> vValue(GravityParticle *p)
1069 {CkAssert(0); return 0.0;}
1070 virtual void setDValue(GravityParticle *p, double val) {
1071 if (TYPETest(p, TYPE_STAR)) p->fStarMFracIron() = val;
1072 if (TYPETest(p, TYPE_GAS)) p->fMFracIron() = val;
1073 }
1074 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1075 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1076 public:
1077 FeOutputParams() {}
1078 FeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1079 bFloat = 1;
1080 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1081 sTipsyExt = "FeMassFrac"; sNChilExt = "FeMassFrac";
1082 dTime = _dTime;
1083 iType = TYPE_GAS | TYPE_STAR; }
1084 PUPable_decl(FeOutputParams);
1085 FeOutputParams(CkMigrateMessage *m) {}
1086 virtual void pup(PUP::er &p) {
1087 OutputParams::pup(p);//Call base class
1088 }
1089 };
1090
1092class MetalsOutputParams : public OutputParams
1093{
1094 virtual double dValue(GravityParticle *p) {
1095 if (TYPETest(p, TYPE_STAR)) return p->fStarMetals();
1096 if (TYPETest(p, TYPE_GAS)) return p->fMetals();
1097 else return 0.0;
1098 }
1099 virtual Vector3D<double> vValue(GravityParticle *p)
1100 {CkAssert(0); return 0.0;}
1101 virtual void setDValue(GravityParticle *p, double val) {
1102 if (TYPETest(p, TYPE_STAR)) p->fStarMetals() = val;
1103 if (TYPETest(p, TYPE_GAS)) p->fMetals() = val;
1104 }
1105 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1106 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1107 public:
1108 MetalsOutputParams() {}
1109 MetalsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1110 bFloat = 1;
1111 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1112 sTipsyExt = "metals"; sNChilExt = "metals";
1113 dTime = _dTime;
1114 iType = TYPE_GAS | TYPE_STAR; }
1115 PUPable_decl(MetalsOutputParams);
1116 MetalsOutputParams(CkMigrateMessage *m) {}
1117 virtual void pup(PUP::er &p) {
1118 OutputParams::pup(p);//Call base class
1119 }
1120 };
1121
1122class MetalsDotOutputParams : public OutputParams
1123{
1124 virtual double dValue(GravityParticle *p) {
1125#ifdef DIFFUSION
1126 if (p->isGas()) return p->fMetalsDot();
1127 else
1128 return 0.0;
1129#endif
1130 }
1131 virtual Vector3D<double> vValue(GravityParticle *p)
1132 {CkAssert(0); return 0.0;}
1133 virtual void setDValue(GravityParticle *p, double val) {
1134#ifdef DIFFUSION
1135 if (p->isGas()) p->fMetalsDot() = val;
1136#endif
1137 }
1138 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1139 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1140 public:
1141 MetalsDotOutputParams() {}
1142 MetalsDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1143 bFloat = 1;
1144 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1145 sTipsyExt = "Metalsdot"; sNChilExt = "Metalsdot";
1146 dTime = _dTime;
1147 iType = TYPE_GAS; }
1148 PUPable_decl(MetalsDotOutputParams);
1149 MetalsDotOutputParams(CkMigrateMessage *m) {}
1150 virtual void pup(PUP::er &p) {
1151 OutputParams::pup(p);//Call base class
1152 }
1153 };
1154
1156class MFormOutputParams : public OutputParams
1157{
1158 virtual double dValue(GravityParticle *p) {
1159 if (TYPETest(p, TYPE_STAR)) return p->fMassForm();
1160 else return 0.0;
1161 }
1162 virtual Vector3D<double> vValue(GravityParticle *p)
1163 {CkAssert(0); return 0.0;}
1164 virtual void setDValue(GravityParticle *p, double val) {
1165 if (TYPETest(p, TYPE_STAR)) p->fMassForm() = val;
1166 }
1167 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1168 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1169 public:
1170 MFormOutputParams() {}
1171 MFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1172 bFloat = 1;
1173 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1174 sTipsyExt = "massform"; sNChilExt = "massform";
1175 dTime = _dTime;
1176 iType = TYPE_STAR; }
1177 PUPable_decl(MFormOutputParams);
1178 MFormOutputParams(CkMigrateMessage *m) {}
1179 virtual void pup(PUP::er &p) {
1180 OutputParams::pup(p);//Call base class
1181 }
1182 };
1183
1185class TimeFormOutputParams : public OutputParams
1186{
1187 virtual double dValue(GravityParticle *p) {
1188 if (TYPETest(p, TYPE_STAR)) return p->fTimeForm();
1189 else return 0.0;
1190 }
1191 virtual Vector3D<double> vValue(GravityParticle *p)
1192 {CkAssert(0); return 0.0;}
1193 virtual void setDValue(GravityParticle *p, double val) {
1194 if (TYPETest(p, TYPE_STAR)) p->fTimeForm() = val;
1195 }
1196 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1197 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1198 public:
1199 TimeFormOutputParams() {}
1200 TimeFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1201 bFloat = 1;
1202 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1203 sTipsyExt = "timeform"; sNChilExt = "timeform";
1204 dTime = _dTime;
1205 iType = TYPE_STAR; }
1206 PUPable_decl(TimeFormOutputParams);
1207 TimeFormOutputParams(CkMigrateMessage *m) {}
1208 virtual void pup(PUP::er &p) {
1209 OutputParams::pup(p);//Call base class
1210 }
1211 };
1212
1214class AgeOutputParams : public OutputParams
1215{
1216 virtual double dValue(GravityParticle *p) {
1217 if (TYPETest(p, TYPE_STAR)) return dTime - p->fTimeForm();
1218 else return 0.0;
1219 }
1220 virtual Vector3D<double> vValue(GravityParticle *p)
1221 {CkAssert(0); return 0.0;}
1222 virtual void setDValue(GravityParticle *p, double val) {
1223 if (TYPETest(p, TYPE_STAR)) p->fTimeForm() = dTime - val;
1224 }
1225 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1226 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1227 public:
1228 AgeOutputParams() {}
1229 AgeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1230 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1231 sTipsyExt = "age"; sNChilExt = "age";
1232 dTime = _dTime;
1233 iType = TYPE_STAR; }
1234 PUPable_decl(AgeOutputParams);
1235 AgeOutputParams(CkMigrateMessage *m) {}
1236 virtual void pup(PUP::er &p) {
1237 OutputParams::pup(p);//Call base class
1238 }
1239 };
1240
1241class OxygenMassFracDotOutputParams : public OutputParams
1242{
1243 virtual double dValue(GravityParticle *p) {
1244#ifdef DIFFUSION
1245 if (p->isGas()) return p->fMFracOxygenDot();
1246 else
1247 return 0.0;
1248#endif
1249 }
1250 virtual Vector3D<double> vValue(GravityParticle *p)
1251 {CkAssert(0); return 0.0;}
1252 virtual void setDValue(GravityParticle *p, double val) {
1253#ifdef DIFFUSION
1254 if (p->isGas()) p->fMFracOxygenDot() = val;
1255#endif
1256 }
1257 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1258 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1259 public:
1260 OxygenMassFracDotOutputParams() {}
1261 OxygenMassFracDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1262 bFloat = 1;
1263 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1264 sTipsyExt = "OxMassFracdot"; sNChilExt = "OxMassFracdot";
1265 dTime = _dTime;
1266 iType = TYPE_GAS; }
1267 PUPable_decl(OxygenMassFracDotOutputParams);
1268 OxygenMassFracDotOutputParams(CkMigrateMessage *m) {}
1269 virtual void pup(PUP::er &p) {
1270 OutputParams::pup(p);//Call base class
1271 }
1272 };
1273
1274class IronMassFracDotOutputParams : public OutputParams
1275{
1276 virtual double dValue(GravityParticle *p) {
1277#ifdef DIFFUSION
1278 if (p->isGas()) return p->fMFracIronDot();
1279 else
1280 return 0.0;
1281#endif
1282 }
1283 virtual Vector3D<double> vValue(GravityParticle *p)
1284 {CkAssert(0); return 0.0;}
1285 virtual void setDValue(GravityParticle *p, double val) {
1286#ifdef DIFFUSION
1287 if (p->isGas()) p->fMFracIronDot() = val;
1288#endif
1289 }
1290 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1291 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1292 public:
1293 IronMassFracDotOutputParams() {}
1294 IronMassFracDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1295 bFloat = 1;
1296 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1297 sTipsyExt = "FeMassFracdot"; sNChilExt = "FeMassFracdot";
1298 dTime = _dTime;
1299 iType = TYPE_GAS; }
1300 PUPable_decl(IronMassFracDotOutputParams);
1301 IronMassFracDotOutputParams(CkMigrateMessage *m) {}
1302 virtual void pup(PUP::er &p) {
1303 OutputParams::pup(p);//Call base class
1304 }
1305 };
1306
1307
1309class coolontimeOutputParams : public OutputParams
1310{
1311 virtual double dValue(GravityParticle *p) {
1312 if (TYPETest(p, TYPE_GAS)) return p->fTimeCoolIsOffUntil();
1313 else return 0.0;
1314 }
1315 virtual Vector3D<double> vValue(GravityParticle *p)
1316 {CkAssert(0); return 0.0;}
1317 virtual void setDValue(GravityParticle *p, double val) {
1318 if (TYPETest(p, TYPE_GAS)) p->fTimeCoolIsOffUntil() = val;
1319 }
1320 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1321 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1322 public:
1323 coolontimeOutputParams() {}
1324 coolontimeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1325 bFloat = 1;
1326 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1327 sTipsyExt = "coolontime"; sNChilExt = "coolontime";
1328 dTime = _dTime;
1329 iType = TYPE_GAS; }
1330 PUPable_decl(coolontimeOutputParams);
1331 coolontimeOutputParams(CkMigrateMessage *m) {}
1332 virtual void pup(PUP::er &p) {
1333 OutputParams::pup(p);//Call base class
1334 }
1335 };
1336
1338class ESNRateOutputParams : public OutputParams
1339{
1340 virtual double dValue(GravityParticle *p) {
1341 if (p->isGas()) return p->fESNrate();
1342 else if(p->isStar()) return p->fStarESNrate();
1343 else return 0.0;
1344 }
1345 virtual Vector3D<double> vValue(GravityParticle *p)
1346 {CkAssert(0); return 0.0;}
1347 virtual void setDValue(GravityParticle *p, double val) {
1348 if (p->isGas()) p->fESNrate() = val;
1349 else if(p->isStar()) p->fStarESNrate() = val;
1350 }
1351 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1352 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1353 public:
1354 ESNRateOutputParams() {}
1355 ESNRateOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1356 bFloat = 1;
1357 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1358 sTipsyExt = "ESNRate"; sNChilExt = "ESNRate";
1359 dTime = _dTime;
1360 iType = TYPE_GAS | TYPE_STAR; }
1361 PUPable_decl(ESNRateOutputParams);
1362 ESNRateOutputParams(CkMigrateMessage *m) {}
1363 virtual void pup(PUP::er &p) {
1364 OutputParams::pup(p);//Call base class
1365 }
1366 };
1367
1369class DtOutputParams : public OutputParams
1370{
1371 virtual double dValue(GravityParticle *p)
1372 {
1373#ifdef NEED_DT
1374 return p->dt;
1375#else
1376 return 0.0;
1377#endif
1378 }
1379 virtual Vector3D<double> vValue(GravityParticle *p)
1380 {CkAssert(0); return 0.0;}
1381 virtual void setDValue(GravityParticle *p, double val) {
1382#ifdef NEED_DT
1383 p->dt = val;
1384#endif
1385 }
1386 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1387 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1388 public:
1389 DtOutputParams() {}
1390 DtOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1391 bFloat = 1;
1392 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1393 sTipsyExt = "dt"; sNChilExt = "dt";
1394 dTime = _dTime;
1395 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1396 PUPable_decl(DtOutputParams);
1397 DtOutputParams(CkMigrateMessage *m) {}
1398 virtual void pup(PUP::er &p) {
1399 OutputParams::pup(p);//Call base class
1400 }
1401 };
1402
1404class KeyOutputParams : public OutputParams
1405{
1406 virtual double dValue(GravityParticle *p)
1407 {
1408 return p->key;
1409 }
1410 virtual Vector3D<double> vValue(GravityParticle *p)
1411 {CkAssert(0); return 0.0;}
1412 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1413 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1414 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1415 public:
1416 KeyOutputParams() {}
1417 KeyOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1418 bFloat = 1;
1419 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1420 sTipsyExt = "key"; sNChilExt = "key";
1421 dTime = _dTime;
1422 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1423 PUPable_decl(KeyOutputParams);
1424 KeyOutputParams(CkMigrateMessage *m) {}
1425 virtual void pup(PUP::er &p) {
1426 OutputParams::pup(p);//Call base class
1427 }
1428 };
1429
1431class DomainOutputParams : public OutputParams
1432{
1433 virtual double dValue(GravityParticle *p)
1434 {
1435 return p->interMass; // Hack: this gets assigned in assignDomain()
1436 // just for this diagnostic.
1437 }
1438 virtual Vector3D<double> vValue(GravityParticle *p)
1439 {CkAssert(0); return 0.0;}
1440 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1441 virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1442 virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1443 public:
1444 DomainOutputParams() {}
1445 DomainOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
1446 DomainOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1447 bFloat = 1;
1448 bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1449 sTipsyExt = "dom"; sNChilExt = "dom";
1450 dTime = _dTime;
1451 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1452 PUPable_decl(DomainOutputParams);
1453 DomainOutputParams(CkMigrateMessage *m) {}
1454 virtual void pup(PUP::er &p) {
1455 OutputParams::pup(p);//Call base class
1456 }
1457 };
1458
1459//SIDM
1460class iNSIDMOutputParams : public OutputParams
1461{
1462 virtual int64_t iValue(GravityParticle *p)
1463 {
1464#ifdef SIDMINTERACT
1465 return p->iNSIDMInteractions;
1466#else
1467 return 0;
1468#endif
1469 }
1470 virtual void setIValue(GravityParticle *p, int64_t iValue)
1471 {
1472#ifdef SIDMINTERACT
1473 p->iNSIDMInteractions= iValue;
1474#endif
1475 }
1476 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1477 virtual Vector3D<double> vValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1478 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1479 public:
1480 iNSIDMOutputParams() {}
1481 iNSIDMOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1482 bFloat=0;
1483 bVector=0;
1484 fileName = _fileName;
1485 iBinaryOut= _iBinaryOut;
1486 sTipsyExt="nsidm"; sNChilExt = "nsidm";
1487 dTime=_dTime;
1488 iType= TYPE_DARK;
1489 }
1490 PUPable_decl(iNSIDMOutputParams);
1491 iNSIDMOutputParams(CkMigrateMessage *m) {}
1492 virtual void pup(PUP::er &p) {
1493 OutputParams::pup(p);//Call base class
1494 }
1495 };
1496
1498class IOrderOutputParams : public OutputParams
1499{
1500 virtual int64_t iValue(GravityParticle *p)
1501 {
1502 return p->iOrder;
1503 }
1504 virtual void setIValue(GravityParticle *p, int64_t iValue)
1505 {
1506 p->iOrder = iValue;
1507 }
1508 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1509 virtual Vector3D<double> vValue(GravityParticle *p)
1510 {CkAssert(0); return 0.0;}
1511 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1512 public:
1513 IOrderOutputParams() {}
1514 IOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1515 bFloat = 0;
1516 bVector = 0;
1517 fileName = _fileName; iBinaryOut = _iBinaryOut;
1518 sTipsyExt = "iord"; sNChilExt = "iord";
1519 dTime = _dTime;
1520 iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1521 PUPable_decl(IOrderOutputParams);
1522 IOrderOutputParams(CkMigrateMessage *m) {}
1523 virtual void pup(PUP::er &p) {
1524 OutputParams::pup(p);//Call base class
1525 }
1526 };
1527
1529class IGasOrderOutputParams : public OutputParams
1530{
1531 virtual int64_t iValue(GravityParticle *p)
1532 {
1533 if(p->isStar())
1534 return p->iGasOrder();
1535 else
1536#ifdef SPLITGAS
1537 if(p->isGas())
1538 return p->iSplitOrder();
1539 else
1540#endif
1541 return 0;
1542 }
1543 virtual void setIValue(GravityParticle *p, int64_t iValue)
1544 {
1545 if(p->isStar()) p->iGasOrder() = iValue;
1546 }
1547 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1548 virtual Vector3D<double> vValue(GravityParticle *p)
1549 {CkAssert(0); return 0.0;}
1550 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1551 public:
1552 IGasOrderOutputParams() {}
1553 IGasOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1554 bFloat = 0;
1555 bVector = 0;
1556 fileName = _fileName; iBinaryOut = _iBinaryOut;
1557 sTipsyExt = "igasorder"; sNChilExt = "igasorder";
1558 dTime = _dTime;
1559 iType = TYPE_STAR; }
1560 PUPable_decl(IGasOrderOutputParams);
1561 IGasOrderOutputParams(CkMigrateMessage *m) {}
1562 virtual void pup(PUP::er &p) {
1563 OutputParams::pup(p);//Call base class
1564 }
1565 };
1566
1568class RungOutputParams : public OutputParams
1569{
1570 virtual int64_t iValue(GravityParticle *p)
1571 {
1572 return p->rung;
1573 }
1574 virtual void setIValue(GravityParticle *p, int64_t iValue)
1575 {
1576 p->rung = iValue;
1577 }
1578 virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1579 virtual Vector3D<double> vValue(GravityParticle *p)
1580 {CkAssert(0); return 0.0;}
1581 virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1582 public:
1583 RungOutputParams() {}
1584 RungOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1585 bFloat = 0;
1586 bVector = 0;
1587 fileName = _fileName; iBinaryOut = _iBinaryOut;
1588 sTipsyExt = "rung"; sNChilExt = "rung";
1589 dTime = _dTime;
1590 iType = TYPE_GAS| TYPE_DARK | TYPE_STAR; }
1591 PUPable_decl(RungOutputParams);
1592 RungOutputParams(CkMigrateMessage *m) {}
1593 virtual void pup(PUP::er &p) {
1594 OutputParams::pup(p);//Call base class
1595 }
1596 };
1597#endif
TYPETest
int TYPETest(const GravityParticle *a, unsigned int b)
Test for a type flag.
Definition GravityParticle.h:606
ncGetCount
int64_t ncGetCount(std::string typedir)
Definition InOutput.cpp:448
AccOutputParams
Output accelerations.
Definition InOutput.h:387
AccOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:390
AccOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:392
AccOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:395
AccOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:396
AccOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:389
AccOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition InOutput.h:393
DataManager
Definition DataManager.h:60
GasDenOutputParams
Output particle gas density.
Definition InOutput.h:318
GasDenOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:321
GasDenOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:323
GasDenOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:325
GasDenOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:324
GasDenOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:320
GravityParticle
Fundamental type for a particle.
Definition GravityParticle.h:364
GravityParticle::fBall
cosmoType fBall
Neighbor search radius for smoothing.
Definition GravityParticle.h:387
GravityParticle::rung
int rung
the current rung (greater means faster)
Definition GravityParticle.h:389
GravityParticle::iOrder
int64_t iOrder
Input order of particles; unique particle ID.
Definition GravityParticle.h:403
MassOutputParams
Output particle masses.
Definition InOutput.h:186
MassOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:189
MassOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:193
MassOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:188
MassOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:191
MassOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:192
OutputParams
Base class for output parameters.
Definition InOutput.h:17
OutputParams::bFloat
int bFloat
Is a floating point number.
Definition InOutput.h:33
OutputParams::setDValue
virtual void setDValue(GravityParticle *p, double d)=0
Input data as a double.
OutputParams::dTime
double dTime
Time of output.
Definition InOutput.h:36
OutputParams::iType
unsigned int iType
mask of families containing this attribute
Definition InOutput.h:40
OutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)=0
Output data as a Vector3D of doubles.
OutputParams::fileName
std::string fileName
output file
Definition InOutput.h:37
OutputParams::sNChilExt
std::string sNChilExt
file name for NChilada output
Definition InOutput.h:39
OutputParams::sTipsyExt
std::string sTipsyExt
Extension for tipsy output.
Definition InOutput.h:38
OutputParams::iValue
virtual int64_t iValue(GravityParticle *p)=0
Output data as an int.
OutputParams::dm
DataManager * dm
For extra state information (e.g. cooling)
Definition InOutput.h:42
OutputParams::dValue
virtual double dValue(GravityParticle *p)=0
Output data as a double.
OutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)=0
Input data as an int.
OutputParams::bVector
int bVector
Is a vector, as opposed to a scalar.
Definition InOutput.h:34
OutputParams::iTypeWriting
unsigned int iTypeWriting
family being written in NC format
Definition InOutput.h:41
OutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > v)
Input data as a Vector3D of doubles.
Definition InOutput.h:26
OutputParams::iBinaryOut
int iBinaryOut
Type of binary output.
Definition InOutput.h:35
PosOutputParams
Output particle positions.
Definition InOutput.h:210
PosOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:215
PosOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:212
PosOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:213
PosOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition InOutput.h:216
PosOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:218
PosOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:219
PotOutputParams
Output particle gravitational potential.
Definition InOutput.h:265
PotOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:267
PotOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:268
PotOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:270
PotOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:272
PotOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:271
SoftOutputParams
Output particle gravitational softenings.
Definition InOutput.h:463
SoftOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:481
SoftOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:482
SoftOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:472
SoftOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:474
SoftOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:465
TempOutputParams
Output particle gas temperature.
Definition InOutput.h:342
TempOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:365
TempOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:362
TempOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:364
TempOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:346
TempOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:366
VelOutputParams
Output particle velocities.
Definition InOutput.h:236
VelOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition InOutput.h:246
VelOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition InOutput.h:239
VelOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition InOutput.h:243
VelOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition InOutput.h:242
VelOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition InOutput.h:245
VelOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition InOutput.h:240
Generated by doxygen 1.13.2