changa  3.5
 All Classes Files Functions Variables Typedefs Enumerations Friends Macros Groups Pages
InOutput.h
Go to the documentation of this file.
1 #ifndef __INOUTPUT_H
4 #define __INOUTPUT_H
5 
6 class OutputParams;
7 #include "DataManager.h"
8 
9 int64_t ncGetCount(std::string typedir);
10 
16 class 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  }
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
62 class 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  };
88 class 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 
114 class 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 
141 class 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
184 class 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 
209 class 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 
235 class 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 
264 class 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 
288 class GasDenOutputParams : public OutputParams
289 {
290  public:
291  virtual double dValue(GravityParticle *p) {return p->fDensity;}
292  virtual Vector3D<double> vValue(GravityParticle *p)
293  {CkAssert(0); return 0.0;}
294  virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
295  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
296  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
297  GasDenOutputParams() {}
298  GasDenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
299  bFloat = 1;
300  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
301  sTipsyExt = "gasden"; sNChilExt = "GasDensity";
302  dTime = _dTime;
303  iType = TYPE_GAS; }
304  PUPable_decl(GasDenOutputParams);
305  GasDenOutputParams(CkMigrateMessage *m) {}
306  virtual void pup(PUP::er &p) {
307  OutputParams::pup(p);//Call base class
308  }
309  };
310 
312 class TempOutputParams : public OutputParams
313 {
314  public:
315  double duTFac;
316  bool bGasCooling;
317  virtual double dValue(GravityParticle *p) {
318  if(bGasCooling) {
319 #ifndef COOLING_NONE
320 #ifdef COOLING_GRACKLE
321  return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
322  p->u(), p->fDensity, p->fMetals());
323 #else
324  return CoolCodeEnergyToTemperature(dm->Cool, &p->CoolParticle(),
325  p->u(), p->fMetals());
326 #endif
327 #else
328  CkAssert(0);
329 #endif
330  }
331  return duTFac*p->u();
332  }
333  virtual Vector3D<double> vValue(GravityParticle *p)
334  {CkAssert(0); return 0.0;}
335  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
336  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
337  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
338  TempOutputParams() {}
339  TempOutputParams(std::string _fileName, int _iBinaryOut, double _dTime,
340  bool _bGasCooling, double _duTFac) {
341  bFloat = 1;
342  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
343  sTipsyExt = "temp"; sNChilExt = "temperature";
344  dTime = _dTime; bGasCooling = _bGasCooling; duTFac = _duTFac;
345  iType = TYPE_GAS; }
346  PUPable_decl(TempOutputParams);
347  TempOutputParams(CkMigrateMessage *m) {}
348  virtual void pup(PUP::er &p) {
349  OutputParams::pup(p);//Call base class
350  p|bGasCooling;
351  p|duTFac;
352  }
353  };
354 
355 
357 class AccOutputParams : public OutputParams
358 {
359  public:
360  virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
361  virtual Vector3D<double> vValue(GravityParticle *p)
362  {return p->treeAcceleration;}
363  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
364  virtual void setVValue(GravityParticle *p, Vector3D<double> val)
365  {p->treeAcceleration = val;}
366  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
367  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
368  AccOutputParams() {}
369  AccOutputParams(std::string _fileName) { bFloat = 1; bVector = 1; fileName = _fileName;}
370  AccOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
371  bFloat = 1;
372  bVector = 1; fileName = _fileName; iBinaryOut = _iBinaryOut;
373  sTipsyExt = "acc2"; sNChilExt = "acc";
374  dTime = _dTime;
375  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
376  PUPable_decl(AccOutputParams);
377  AccOutputParams(CkMigrateMessage *m) {}
378  virtual void pup(PUP::er &p) {
379  OutputParams::pup(p);//Call base class
380  }
381  };
382 
384 class DenOutputParams : public OutputParams
385 {
386  virtual double dValue(GravityParticle *p) {return p->fDensity;}
387  virtual Vector3D<double> vValue(GravityParticle *p)
388  {CkAssert(0); return 0.0;}
389  virtual void setDValue(GravityParticle *p, double val) {p->fDensity = val;}
390  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
391  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
392  public:
393  DenOutputParams() {}
394  DenOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
395  DenOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
396  bFloat = 1;
397  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
398  sTipsyExt = "den"; sNChilExt = "den";
399  dTime = _dTime;
400  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
401  PUPable_decl(DenOutputParams);
402  DenOutputParams(CkMigrateMessage *m) {}
403  virtual void pup(PUP::er &p) {
404  OutputParams::pup(p);//Call base class
405  }
406  };
407 
409 class HsmOutputParams : public OutputParams
410 {
411  virtual double dValue(GravityParticle *p) {return 0.5*p->fBall;}
412  virtual Vector3D<double> vValue(GravityParticle *p)
413  {CkAssert(0); return 0.0;}
414  virtual void setDValue(GravityParticle *p, double val) {p->fBall = 2.0*val;}
415  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
416  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
417  public:
418  HsmOutputParams() {}
419  HsmOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
420  bFloat = 1;
421  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
422  sTipsyExt = "smoothlength"; sNChilExt = "smoothlength";
423  dTime = _dTime;
424  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
425  PUPable_decl(HsmOutputParams);
426  HsmOutputParams(CkMigrateMessage *m) {}
427  virtual void pup(PUP::er &p) {
428  OutputParams::pup(p);//Call base class
429  }
430  };
431 
433 class SoftOutputParams : public OutputParams
434 {
435  public:
436  virtual double dValue(GravityParticle *p) {
437 #ifdef CHANGESOFT
438  return p->fSoft0;
439 #else
440  return p->soft;
441 #endif
442  }
443  virtual Vector3D<double> vValue(GravityParticle *p)
444  {CkAssert(0); return 0.0;}
445  virtual void setDValue(GravityParticle *p, double val) {
446 #ifdef CHANGESOFT
447  p->fSoft0 = val;
448 #else
449  p->soft = val;
450 #endif
451  }
452  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
453  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
454  SoftOutputParams() {}
455  SoftOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
456  bFloat = 1;
457  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
458  sTipsyExt = "soft"; sNChilExt = "soft";
459  dTime = _dTime;
460  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
461  PUPable_decl(SoftOutputParams);
462  SoftOutputParams(CkMigrateMessage *m) {}
463  virtual void pup(PUP::er &p) {
464  OutputParams::pup(p);//Call base class
465  }
466  };
467 
469 class PresOutputParams : public OutputParams
470 {
471  virtual double dValue(GravityParticle *p)
472  {
473  if (TYPETest(p, TYPE_GAS))
474  return p->fDensity*p->fDensity*p->PoverRho2();
475  else
476  return 0.0;
477  }
478  virtual Vector3D<double> vValue(GravityParticle *p)
479  {CkAssert(0); return 0.0;}
480  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
481  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
482  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
483  public:
484  PresOutputParams() {}
485  PresOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
486  PresOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
487  bFloat = 1;
488  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
489  sTipsyExt = "pres"; sNChilExt = "pres";
490  dTime = _dTime;
491  iType = TYPE_GAS; }
492  PUPable_decl(PresOutputParams);
493  PresOutputParams(CkMigrateMessage *m) {}
494  virtual void pup(PUP::er &p) {
495  OutputParams::pup(p);//Call base class
496  }
497  };
498 
500 class AlphaOutputParams : public OutputParams
501 {
502  virtual double dValue(GravityParticle *p)
503  {
504 #ifdef CULLENALPHA
505  if (p->isGas())
506  return p->CullenAlpha();
507  else
508 #endif /* CULLENALPHA */
509  return 0.0;
510  }
511  virtual Vector3D<double> vValue(GravityParticle *p)
512  {CkAssert(0); return 0.0;}
513  virtual void setDValue(GravityParticle *p, double val) {
514 #ifdef CULLENALPHA
515  if(p->isGas())
516  p->CullenAlpha() = val;
517 #endif
518  }
519  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
520  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
521  public:
522  AlphaOutputParams() {}
523  AlphaOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
524  AlphaOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
525  bFloat = 1;
526  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
527  sTipsyExt = "alpha"; sNChilExt = "alpha";
528  dTime = _dTime;
529  iType = TYPE_GAS; }
530  PUPable_decl(AlphaOutputParams);
531  AlphaOutputParams(CkMigrateMessage *m) {}
532  virtual void pup(PUP::er &p) {
533  OutputParams::pup(p);//Call base class
534  }
535 };
536 
538 class DvDsOutputParams : public OutputParams
539 {
540  virtual double dValue(GravityParticle *p)
541  {
542 #ifdef CULLENALPHA
543  if (TYPETest(p, TYPE_GAS))
544  return p->dvds();
545  else
546 #endif /* CULLENALPHA */
547  return 0.0;
548  }
549  virtual Vector3D<double> vValue(GravityParticle *p)
550  {CkAssert(0); return 0.0;}
551  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
552  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
553  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
554  public:
555  DvDsOutputParams() {}
556  DvDsOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
557  DvDsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
558  bFloat = 1;
559  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
560  sTipsyExt = "dvds"; sNChilExt = "dvds";
561  dTime = _dTime;
562  iType = TYPE_GAS; }
563  PUPable_decl(DvDsOutputParams);
564  DvDsOutputParams(CkMigrateMessage *m) {}
565  virtual void pup(PUP::er &p) {
566  OutputParams::pup(p); //Call base class
567  }
568 };
569 
570 
572 class DivVOutputParams : public OutputParams
573 {
574  virtual double dValue(GravityParticle *p)
575  {
576  if (TYPETest(p, TYPE_GAS))
577  return p->divv();
578  else
579  return 0.0;
580  }
581  virtual Vector3D<double> vValue(GravityParticle *p)
582  {CkAssert(0); return 0.0;}
583  virtual void setDValue(GravityParticle *p, double val) {p->divv() = val;}
584  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
585  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
586  public:
587  DivVOutputParams() {}
588  DivVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
589  bFloat = 1;
590  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
591  sTipsyExt = "divv"; sNChilExt = "divv";
592  dTime = _dTime;
593  iType = TYPE_GAS; }
594  PUPable_decl(DivVOutputParams);
595  DivVOutputParams(CkMigrateMessage *m) {}
596  virtual void pup(PUP::er &p) {
597  OutputParams::pup(p);//Call base class
598  }
599  };
600 
602 class PDVOutputParams : public OutputParams
603 {
604  virtual double dValue(GravityParticle *p)
605  {
606  if (TYPETest(p, TYPE_GAS))
607  return p->PdV();
608  else
609  return 0.0;
610  }
611  virtual Vector3D<double> vValue(GravityParticle *p)
612  {CkAssert(0); return 0.0;}
613  virtual void setDValue(GravityParticle *p, double val) {p->PdV() = val;}
614  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
615  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
616  public:
617  PDVOutputParams() {}
618  PDVOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
619  PDVOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
620  bFloat = 1;
621  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
622  sTipsyExt = "PdV"; sNChilExt = "PdV";
623  dTime = _dTime;
624  iType = TYPE_GAS; }
625  PUPable_decl(PDVOutputParams);
626  PDVOutputParams(CkMigrateMessage *m) {}
627  virtual void pup(PUP::er &p) {
628  OutputParams::pup(p);//Call base class
629  }
630  };
631 
633 class MuMaxOutputParams : public OutputParams
634 {
635  virtual double dValue(GravityParticle *p)
636  {
637  if (TYPETest(p, TYPE_GAS))
638  return p->mumax();
639  else
640  return 0.0;
641  }
642  virtual Vector3D<double> vValue(GravityParticle *p)
643  {CkAssert(0); return 0.0;}
644  virtual void setDValue(GravityParticle *p, double val) {p->mumax() = val;}
645  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
646  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
647  public:
648  MuMaxOutputParams() {}
649  MuMaxOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
650  MuMaxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
651  bFloat = 1;
652  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
653  sTipsyExt = "mumax"; sNChilExt = "mumax";
654  dTime = _dTime;
655  iType = TYPE_GAS; }
656  PUPable_decl(MuMaxOutputParams);
657  MuMaxOutputParams(CkMigrateMessage *m) {}
658  virtual void pup(PUP::er &p) {
659  OutputParams::pup(p);//Call base class
660  }
661  };
662 
664 class BSwOutputParams : public OutputParams
665 {
666  virtual double dValue(GravityParticle *p)
667  {
668  if (TYPETest(p, TYPE_GAS))
669  return p->BalsaraSwitch();
670  else
671  return 0.0;
672  }
673  virtual Vector3D<double> vValue(GravityParticle *p)
674  {CkAssert(0); return 0.0;}
675  virtual void setDValue(GravityParticle *p, double val) {p->BalsaraSwitch() = val;}
676  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
677  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
678  public:
679  BSwOutputParams() {}
680  BSwOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
681  bFloat = 1;
682  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
683  sTipsyExt = "BSw"; sNChilExt = "BSw";
684  dTime = _dTime;
685  iType = TYPE_GAS; }
686  PUPable_decl(BSwOutputParams);
687  BSwOutputParams(CkMigrateMessage *m) {}
688  virtual void pup(PUP::er &p) {
689  OutputParams::pup(p);//Call base class
690  }
691  };
692 
694 class CsOutputParams : public OutputParams
695 {
696  virtual double dValue(GravityParticle *p)
697  {
698  if (TYPETest(p, TYPE_GAS))
699  return p->c();
700  else
701  return 0.0;
702  }
703  virtual Vector3D<double> vValue(GravityParticle *p)
704  {CkAssert(0); return 0.0;}
705  virtual void setDValue(GravityParticle *p, double val) {p->c() = val;}
706  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
707  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
708  public:
709  CsOutputParams() {}
710  CsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
711  bFloat = 1;
712  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
713  sTipsyExt = "c"; sNChilExt = "c";
714  dTime = _dTime;
715  iType = TYPE_GAS; }
716  PUPable_decl(CsOutputParams);
717  CsOutputParams(CkMigrateMessage *m) {}
718  virtual void pup(PUP::er &p) {
719  OutputParams::pup(p);//Call base class
720  }
721  };
722 
724 class EDotOutputParams : public OutputParams
725 {
726  virtual double dValue(GravityParticle *p)
727  {
728 #ifndef COOLING_NONE
729  CkAssert(dm != NULL);
730  if (TYPETest(p, TYPE_GAS)) {
731  double r[3]; // For conversion to C
732  p->position.array_form(r);
733 #ifdef COOLING_MOLECULARH
734  return (COOL_EDOT(dm->Cool, &p->CoolParticle(), p->u(), p->fDensity, p->fMetals(), r, sqrt(0.25)*(p->fBall)));
735 #else
736  return (COOL_EDOT(dm->Cool, &p->CoolParticle(), p->u(), p->fDensity, p->fMetals(), r));
737 #endif
738  }
739  else
740 #endif
741  return 0.0;
742  }
743  virtual Vector3D<double> vValue(GravityParticle *p)
744  {CkAssert(0); return 0.0;}
745  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
746  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
747  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
748  public:
749  EDotOutputParams() {}
750  EDotOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
751  EDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
752  bFloat = 1;
753  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
754  sTipsyExt = "eDot"; sNChilExt = "eDot";
755  dTime = _dTime;
756  iType = TYPE_GAS; }
757  PUPable_decl(EDotOutputParams);
758  EDotOutputParams(CkMigrateMessage *m) {}
759  virtual void pup(PUP::er &p) {
760  OutputParams::pup(p);//Call base class
761  }
762  };
763 
765 class Cool0OutputParams : public OutputParams
766 {
767  virtual double dValue(GravityParticle *p)
768  {
769 #ifndef COOLING_NONE
770  CkAssert(dm != NULL);
771  if (TYPETest(p, TYPE_GAS))
772  return COOL_ARRAY0(dm->Cool, &p->CoolParticle(), p->fMetals());
773  else
774 #endif
775  return 0.0;
776  }
777  virtual Vector3D<double> vValue(GravityParticle *p)
778  {CkAssert(0); return 0.0;}
779  virtual void setDValue(GravityParticle *p, double val) {
780 #ifndef COOLING_NONE
781  if (TYPETest(p, TYPE_GAS))
782  COOL_SET_ARRAY0(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
783 #endif
784  }
785  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
786  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
787  public:
788  Cool0OutputParams() {}
789  Cool0OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
790  bFloat = 1;
791  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
792 #ifndef COOLING_NONE
793  sTipsyExt = COOL_ARRAY0_EXT; sNChilExt = COOL_ARRAY0_EXT;
794 #endif
795  dTime = _dTime;
796  iType = TYPE_GAS; }
797  PUPable_decl(Cool0OutputParams);
798  Cool0OutputParams(CkMigrateMessage *m) {}
799  virtual void pup(PUP::er &p) {
800  OutputParams::pup(p);//Call base class
801  }
802  };
803 
805 class Cool1OutputParams : public OutputParams
806 {
807  virtual double dValue(GravityParticle *p)
808  {
809 #ifndef COOLING_NONE
810  CkAssert(dm != NULL);
811  if (TYPETest(p, TYPE_GAS))
812  return COOL_ARRAY1(dm->Cool, &p->CoolParticle(), p->fMetals());
813  else
814 #endif
815  return 0.0;
816  }
817  virtual Vector3D<double> vValue(GravityParticle *p)
818  {CkAssert(0); return 0.0;}
819  virtual void setDValue(GravityParticle *p, double val) {
820 #ifndef COOLING_NONE
821  //XXX be sure metals has been set!
822  if (TYPETest(p, TYPE_GAS))
823  COOL_SET_ARRAY1(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
824 #endif
825  }
826  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
827  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
828  public:
829  Cool1OutputParams() {}
830  Cool1OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
831  bFloat = 1;
832  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
833 #ifndef COOLING_NONE
834  sTipsyExt = COOL_ARRAY1_EXT; sNChilExt = COOL_ARRAY1_EXT;
835 #endif
836  dTime = _dTime;
837  iType = TYPE_GAS; }
838  PUPable_decl(Cool1OutputParams);
839  Cool1OutputParams(CkMigrateMessage *m) {}
840  virtual void pup(PUP::er &p) {
841  OutputParams::pup(p);//Call base class
842  }
843  };
844 
846 class Cool2OutputParams : public OutputParams
847 {
848  virtual double dValue(GravityParticle *p)
849  {
850 #ifndef COOLING_NONE
851  CkAssert(dm != NULL);
852  if (TYPETest(p, TYPE_GAS))
853  return COOL_ARRAY2(dm->Cool, &p->CoolParticle(), p->fMetals());
854  else
855 #endif
856  return 0.0;
857  }
858  virtual Vector3D<double> vValue(GravityParticle *p)
859  {CkAssert(0); return 0.0;}
860  virtual void setDValue(GravityParticle *p, double val) {
861 #ifndef COOLING_NONE
862  if (TYPETest(p, TYPE_GAS))
863  COOL_SET_ARRAY2(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
864 #endif
865  }
866  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
867  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
868  public:
869  Cool2OutputParams() {}
870  Cool2OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
871  bFloat = 1;
872  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
873 #ifndef COOLING_NONE
874  sTipsyExt = COOL_ARRAY2_EXT; sNChilExt = COOL_ARRAY2_EXT;
875 #endif
876  dTime = _dTime;
877  iType = TYPE_GAS; }
878  PUPable_decl(Cool2OutputParams);
879  Cool2OutputParams(CkMigrateMessage *m) {}
880  virtual void pup(PUP::er &p) {
881  OutputParams::pup(p);//Call base class
882  }
883  };
884 
885 
887 class Cool3OutputParams : public OutputParams
888 {
889  virtual double dValue(GravityParticle *p)
890  {
891 #ifndef COOLING_NONE
892 #ifdef COOLING_MOLECULARH
893  CkAssert(dm != NULL);
894  if (TYPETest(p, TYPE_GAS))
895  return COOL_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals());
896  else
897 #else /*COOLING_MOLECULARH*/
898  if (TYPETest(p, TYPE_GAS))
899  return COOL_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals());
900  else
901 #endif /*COOLING_MOLECULARH*/
902 #endif /*COOLING_NONE*/
903  return 0.0;
904  }
905  virtual Vector3D<double> vValue(GravityParticle *p)
906  {CkAssert(0); return 0.0;}
907  virtual void setDValue(GravityParticle *p, double val) {
908 #ifndef COOLING_NONE
909  if (TYPETest(p, TYPE_GAS))
910 #ifdef COOLING_MOLECULARH
911  COOL_SET_ARRAY3(dm->Cool, &p->CoolParticle(), p->fMetals(), val);
912 #else /*COOLING_MOLECULARH*/
913  CkAssert(0);
914 #endif /*COOLING_MOLECULARH*/
915 #endif /*COOLING_NONE*/
916  }
917  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
918  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
919  public:
920  Cool3OutputParams() {}
921  Cool3OutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
922  bFloat = 1;
923  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
924 #ifndef COOLING_NONE
925  sTipsyExt = COOL_ARRAY3_EXT; sNChilExt = COOL_ARRAY3_EXT;
926 #endif
927  dTime = _dTime;
928  iType = TYPE_GAS; }
929  PUPable_decl(Cool3OutputParams);
930  Cool3OutputParams(CkMigrateMessage *m) {}
931  virtual void pup(PUP::er &p) {
932  OutputParams::pup(p);//Call base class
933  }
934 };
935 
936 #ifdef COOLING_MOLECULARH
937 class LWOutputParams : public OutputParams
938 {
939  virtual double dValue(GravityParticle *p) {
940  if (TYPETest(p, TYPE_STAR)) return p->dStarLymanWerner();
941  if (TYPETest(p, TYPE_GAS)) return p->CoolParticle().dLymanWerner;
942  else return 0.0;
943  }
944  virtual Vector3D<double> vValue(GravityParticle *p)
945  {CkAssert(0); return 0.0;}
946  virtual void setDValue(GravityParticle *p, double val) {
947  if (TYPETest(p, TYPE_STAR)) p->dStarLymanWerner() = val;
948  if (TYPETest(p, TYPE_GAS)) p->CoolParticle().dLymanWerner = val;
949  }
950  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
951  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
952  public:
953  LWOutputParams() {}
954  LWOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
955  bFloat = 1;
956  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
957  sTipsyExt = "lw"; sNChilExt = "lw";
958  dTime = _dTime;
959  iType = TYPE_GAS | TYPE_STAR; }
960  PUPable_decl(LWOutputParams);
961  LWOutputParams(CkMigrateMessage *m) {}
962  virtual void pup(PUP::er &p) {
963  OutputParams::pup(p);//Call base class
964  }
965  };
966 #endif /*COOLING_MOLECULARH*/
967 
969 class OxOutputParams : public OutputParams
970 {
971  virtual double dValue(GravityParticle *p) {
972  if (TYPETest(p, TYPE_STAR)) return p->fStarMFracOxygen();
973  if (TYPETest(p, TYPE_GAS)) return p->fMFracOxygen();
974  else return 0.0;
975  }
976  virtual Vector3D<double> vValue(GravityParticle *p)
977  {CkAssert(0); return 0.0;}
978  virtual void setDValue(GravityParticle *p, double val) {
979  if (TYPETest(p, TYPE_STAR)) p->fStarMFracOxygen() = val;
980  if (TYPETest(p, TYPE_GAS)) p->fMFracOxygen() = val;
981  }
982  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
983  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
984  public:
985  OxOutputParams() {}
986  OxOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
987  bFloat = 1;
988  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
989  sTipsyExt = "OxMassFrac"; sNChilExt = "OxMassFrac";
990  dTime = _dTime;
991  iType = TYPE_GAS | TYPE_STAR; }
992  PUPable_decl(OxOutputParams);
993  OxOutputParams(CkMigrateMessage *m) {}
994  virtual void pup(PUP::er &p) {
995  OutputParams::pup(p);//Call base class
996  }
997  };
998 
1000 class FeOutputParams : public OutputParams
1001 {
1002  virtual double dValue(GravityParticle *p) {
1003  if (TYPETest(p, TYPE_STAR)) return p->fStarMFracIron();
1004  if (TYPETest(p, TYPE_GAS)) return p->fMFracIron();
1005  else return 0.0;
1006  }
1007  virtual Vector3D<double> vValue(GravityParticle *p)
1008  {CkAssert(0); return 0.0;}
1009  virtual void setDValue(GravityParticle *p, double val) {
1010  if (TYPETest(p, TYPE_STAR)) p->fStarMFracIron() = val;
1011  if (TYPETest(p, TYPE_GAS)) p->fMFracIron() = val;
1012  }
1013  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1014  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1015  public:
1016  FeOutputParams() {}
1017  FeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1018  bFloat = 1;
1019  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1020  sTipsyExt = "FeMassFrac"; sNChilExt = "FeMassFrac";
1021  dTime = _dTime;
1022  iType = TYPE_GAS | TYPE_STAR; }
1023  PUPable_decl(FeOutputParams);
1024  FeOutputParams(CkMigrateMessage *m) {}
1025  virtual void pup(PUP::er &p) {
1026  OutputParams::pup(p);//Call base class
1027  }
1028  };
1029 
1031 class MetalsOutputParams : public OutputParams
1032 {
1033  virtual double dValue(GravityParticle *p) {
1034  if (TYPETest(p, TYPE_STAR)) return p->fStarMetals();
1035  if (TYPETest(p, TYPE_GAS)) return p->fMetals();
1036  else return 0.0;
1037  }
1038  virtual Vector3D<double> vValue(GravityParticle *p)
1039  {CkAssert(0); return 0.0;}
1040  virtual void setDValue(GravityParticle *p, double val) {
1041  if (TYPETest(p, TYPE_STAR)) p->fStarMetals() = val;
1042  if (TYPETest(p, TYPE_GAS)) p->fMetals() = val;
1043  }
1044  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1045  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1046  public:
1047  MetalsOutputParams() {}
1048  MetalsOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1049  bFloat = 1;
1050  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1051  sTipsyExt = "metals"; sNChilExt = "metals";
1052  dTime = _dTime;
1053  iType = TYPE_GAS | TYPE_STAR; }
1054  PUPable_decl(MetalsOutputParams);
1055  MetalsOutputParams(CkMigrateMessage *m) {}
1056  virtual void pup(PUP::er &p) {
1057  OutputParams::pup(p);//Call base class
1058  }
1059  };
1060 
1061 class MetalsDotOutputParams : public OutputParams
1062 {
1063  virtual double dValue(GravityParticle *p) {
1064 #ifdef DIFFUSION
1065  if (p->isGas()) return p->fMetalsDot();
1066  else
1067  return 0.0;
1068 #endif
1069  }
1070  virtual Vector3D<double> vValue(GravityParticle *p)
1071  {CkAssert(0); return 0.0;}
1072  virtual void setDValue(GravityParticle *p, double val) {
1073 #ifdef DIFFUSION
1074  if (p->isGas()) p->fMetalsDot() = val;
1075 #endif
1076  }
1077  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1078  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1079  public:
1080  MetalsDotOutputParams() {}
1081  MetalsDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1082  bFloat = 1;
1083  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1084  sTipsyExt = "Metalsdot"; sNChilExt = "Metalsdot";
1085  dTime = _dTime;
1086  iType = TYPE_GAS; }
1087  PUPable_decl(MetalsDotOutputParams);
1088  MetalsDotOutputParams(CkMigrateMessage *m) {}
1089  virtual void pup(PUP::er &p) {
1090  OutputParams::pup(p);//Call base class
1091  }
1092  };
1093 
1095 class MFormOutputParams : public OutputParams
1096 {
1097  virtual double dValue(GravityParticle *p) {
1098  if (TYPETest(p, TYPE_STAR)) return p->fMassForm();
1099  else return 0.0;
1100  }
1101  virtual Vector3D<double> vValue(GravityParticle *p)
1102  {CkAssert(0); return 0.0;}
1103  virtual void setDValue(GravityParticle *p, double val) {
1104  if (TYPETest(p, TYPE_STAR)) p->fMassForm() = val;
1105  }
1106  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1107  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1108  public:
1109  MFormOutputParams() {}
1110  MFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1111  bFloat = 1;
1112  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1113  sTipsyExt = "massform"; sNChilExt = "massform";
1114  dTime = _dTime;
1115  iType = TYPE_STAR; }
1116  PUPable_decl(MFormOutputParams);
1117  MFormOutputParams(CkMigrateMessage *m) {}
1118  virtual void pup(PUP::er &p) {
1119  OutputParams::pup(p);//Call base class
1120  }
1121  };
1122 
1124 class TimeFormOutputParams : public OutputParams
1125 {
1126  virtual double dValue(GravityParticle *p) {
1127  if (TYPETest(p, TYPE_STAR)) return p->fTimeForm();
1128  else return 0.0;
1129  }
1130  virtual Vector3D<double> vValue(GravityParticle *p)
1131  {CkAssert(0); return 0.0;}
1132  virtual void setDValue(GravityParticle *p, double val) {
1133  if (TYPETest(p, TYPE_STAR)) p->fTimeForm() = val;
1134  }
1135  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1136  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1137  public:
1138  TimeFormOutputParams() {}
1139  TimeFormOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1140  bFloat = 1;
1141  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1142  sTipsyExt = "timeform"; sNChilExt = "timeform";
1143  dTime = _dTime;
1144  iType = TYPE_STAR; }
1145  PUPable_decl(TimeFormOutputParams);
1146  TimeFormOutputParams(CkMigrateMessage *m) {}
1147  virtual void pup(PUP::er &p) {
1148  OutputParams::pup(p);//Call base class
1149  }
1150  };
1151 
1153 class AgeOutputParams : public OutputParams
1154 {
1155  virtual double dValue(GravityParticle *p) {
1156  if (TYPETest(p, TYPE_STAR)) return dTime - p->fTimeForm();
1157  else return 0.0;
1158  }
1159  virtual Vector3D<double> vValue(GravityParticle *p)
1160  {CkAssert(0); return 0.0;}
1161  virtual void setDValue(GravityParticle *p, double val) {
1162  if (TYPETest(p, TYPE_STAR)) p->fTimeForm() = dTime - val;
1163  }
1164  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1165  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1166  public:
1167  AgeOutputParams() {}
1168  AgeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1169  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1170  sTipsyExt = "age"; sNChilExt = "age";
1171  dTime = _dTime;
1172  iType = TYPE_STAR; }
1173  PUPable_decl(AgeOutputParams);
1174  AgeOutputParams(CkMigrateMessage *m) {}
1175  virtual void pup(PUP::er &p) {
1176  OutputParams::pup(p);//Call base class
1177  }
1178  };
1179 
1180 class OxygenMassFracDotOutputParams : public OutputParams
1181 {
1182  virtual double dValue(GravityParticle *p) {
1183 #ifdef DIFFUSION
1184  if (p->isGas()) return p->fMFracOxygenDot();
1185  else
1186  return 0.0;
1187 #endif
1188  }
1189  virtual Vector3D<double> vValue(GravityParticle *p)
1190  {CkAssert(0); return 0.0;}
1191  virtual void setDValue(GravityParticle *p, double val) {
1192 #ifdef DIFFUSION
1193  if (p->isGas()) p->fMFracOxygenDot() = val;
1194 #endif
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  OxygenMassFracDotOutputParams() {}
1200  OxygenMassFracDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1201  bFloat = 1;
1202  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1203  sTipsyExt = "OxMassFracdot"; sNChilExt = "OxMassFracdot";
1204  dTime = _dTime;
1205  iType = TYPE_GAS; }
1206  PUPable_decl(OxygenMassFracDotOutputParams);
1207  OxygenMassFracDotOutputParams(CkMigrateMessage *m) {}
1208  virtual void pup(PUP::er &p) {
1209  OutputParams::pup(p);//Call base class
1210  }
1211  };
1212 
1213 class IronMassFracDotOutputParams : public OutputParams
1214 {
1215  virtual double dValue(GravityParticle *p) {
1216 #ifdef DIFFUSION
1217  if (p->isGas()) return p->fMFracIronDot();
1218  else
1219  return 0.0;
1220 #endif
1221  }
1222  virtual Vector3D<double> vValue(GravityParticle *p)
1223  {CkAssert(0); return 0.0;}
1224  virtual void setDValue(GravityParticle *p, double val) {
1225 #ifdef DIFFUSION
1226  if (p->isGas()) p->fMFracIronDot() = val;
1227 #endif
1228  }
1229  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1230  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1231  public:
1232  IronMassFracDotOutputParams() {}
1233  IronMassFracDotOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1234  bFloat = 1;
1235  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1236  sTipsyExt = "FeMassFracdot"; sNChilExt = "FeMassFracdot";
1237  dTime = _dTime;
1238  iType = TYPE_GAS; }
1239  PUPable_decl(IronMassFracDotOutputParams);
1240  IronMassFracDotOutputParams(CkMigrateMessage *m) {}
1241  virtual void pup(PUP::er &p) {
1242  OutputParams::pup(p);//Call base class
1243  }
1244  };
1245 
1246 
1248 class coolontimeOutputParams : public OutputParams
1249 {
1250  virtual double dValue(GravityParticle *p) {
1251  if (TYPETest(p, TYPE_GAS)) return p->fTimeCoolIsOffUntil();
1252  else return 0.0;
1253  }
1254  virtual Vector3D<double> vValue(GravityParticle *p)
1255  {CkAssert(0); return 0.0;}
1256  virtual void setDValue(GravityParticle *p, double val) {
1257  if (TYPETest(p, TYPE_GAS)) p->fTimeCoolIsOffUntil() = val;
1258  }
1259  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1260  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1261  public:
1262  coolontimeOutputParams() {}
1263  coolontimeOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1264  bFloat = 1;
1265  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1266  sTipsyExt = "coolontime"; sNChilExt = "coolontime";
1267  dTime = _dTime;
1268  iType = TYPE_GAS; }
1269  PUPable_decl(coolontimeOutputParams);
1270  coolontimeOutputParams(CkMigrateMessage *m) {}
1271  virtual void pup(PUP::er &p) {
1272  OutputParams::pup(p);//Call base class
1273  }
1274  };
1275 
1277 class ESNRateOutputParams : public OutputParams
1278 {
1279  virtual double dValue(GravityParticle *p) {
1280  if (p->isGas()) return p->fESNrate();
1281  else if(p->isStar()) return p->fStarESNrate();
1282  else return 0.0;
1283  }
1284  virtual Vector3D<double> vValue(GravityParticle *p)
1285  {CkAssert(0); return 0.0;}
1286  virtual void setDValue(GravityParticle *p, double val) {
1287  if (p->isGas()) p->fESNrate() = val;
1288  else if(p->isStar()) p->fStarESNrate() = val;
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  ESNRateOutputParams() {}
1294  ESNRateOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1295  bFloat = 1;
1296  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1297  sTipsyExt = "ESNRate"; sNChilExt = "ESNRate";
1298  dTime = _dTime;
1299  iType = TYPE_GAS | TYPE_STAR; }
1300  PUPable_decl(ESNRateOutputParams);
1301  ESNRateOutputParams(CkMigrateMessage *m) {}
1302  virtual void pup(PUP::er &p) {
1303  OutputParams::pup(p);//Call base class
1304  }
1305  };
1306 
1308 class DtOutputParams : public OutputParams
1309 {
1310  virtual double dValue(GravityParticle *p)
1311  {
1312 #ifdef NEED_DT
1313  return p->dt;
1314 #else
1315  return 0.0;
1316 #endif
1317  }
1318  virtual Vector3D<double> vValue(GravityParticle *p)
1319  {CkAssert(0); return 0.0;}
1320  virtual void setDValue(GravityParticle *p, double val) {
1321 #ifdef NEED_DT
1322  p->dt = val;
1323 #endif
1324  }
1325  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1326  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1327  public:
1328  DtOutputParams() {}
1329  DtOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1330  bFloat = 1;
1331  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1332  sTipsyExt = "dt"; sNChilExt = "dt";
1333  dTime = _dTime;
1334  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1335  PUPable_decl(DtOutputParams);
1336  DtOutputParams(CkMigrateMessage *m) {}
1337  virtual void pup(PUP::er &p) {
1338  OutputParams::pup(p);//Call base class
1339  }
1340  };
1341 
1343 class KeyOutputParams : public OutputParams
1344 {
1345  virtual double dValue(GravityParticle *p)
1346  {
1347  return p->key;
1348  }
1349  virtual Vector3D<double> vValue(GravityParticle *p)
1350  {CkAssert(0); return 0.0;}
1351  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1352  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1353  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1354  public:
1355  KeyOutputParams() {}
1356  KeyOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1357  bFloat = 1;
1358  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1359  sTipsyExt = "key"; sNChilExt = "key";
1360  dTime = _dTime;
1361  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1362  PUPable_decl(KeyOutputParams);
1363  KeyOutputParams(CkMigrateMessage *m) {}
1364  virtual void pup(PUP::er &p) {
1365  OutputParams::pup(p);//Call base class
1366  }
1367  };
1368 
1370 class DomainOutputParams : public OutputParams
1371 {
1372  virtual double dValue(GravityParticle *p)
1373  {
1374  return p->interMass; // Hack: this gets assigned in assignDomain()
1375  // just for this diagnostic.
1376  }
1377  virtual Vector3D<double> vValue(GravityParticle *p)
1378  {CkAssert(0); return 0.0;}
1379  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1380  virtual int64_t iValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1381  virtual void setIValue(GravityParticle *p, int64_t iValue) {CkAssert(0);}
1382  public:
1383  DomainOutputParams() {}
1384  DomainOutputParams(std::string _fileName) { bFloat = 1; bVector = 0; fileName = _fileName;}
1385  DomainOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1386  bFloat = 1;
1387  bVector = 0; fileName = _fileName; iBinaryOut = _iBinaryOut;
1388  sTipsyExt = "dom"; sNChilExt = "dom";
1389  dTime = _dTime;
1390  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1391  PUPable_decl(DomainOutputParams);
1392  DomainOutputParams(CkMigrateMessage *m) {}
1393  virtual void pup(PUP::er &p) {
1394  OutputParams::pup(p);//Call base class
1395  }
1396  };
1397 
1398 //SIDM
1399 class iNSIDMOutputParams : public OutputParams
1400 {
1401  virtual int64_t iValue(GravityParticle *p)
1402  {
1403 #ifdef SIDMINTERACT
1404  return p->iNSIDMInteractions;
1405 #else
1406  return 0;
1407 #endif
1408  }
1409  virtual void setIValue(GravityParticle *p, int64_t iValue)
1410  {
1411 #ifdef SIDMINTERACT
1412  p->iNSIDMInteractions= iValue;
1413 #endif
1414  }
1415  virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1416  virtual Vector3D<double> vValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1417  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1418  public:
1419  iNSIDMOutputParams() {}
1420  iNSIDMOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1421  bFloat=0;
1422  bVector=0;
1423  fileName = _fileName;
1424  iBinaryOut= _iBinaryOut;
1425  sTipsyExt="nsidm"; sNChilExt = "nsidm";
1426  dTime=_dTime;
1427  iType= TYPE_DARK;
1428  }
1429  PUPable_decl(iNSIDMOutputParams);
1430  iNSIDMOutputParams(CkMigrateMessage *m) {}
1431  virtual void pup(PUP::er &p) {
1432  OutputParams::pup(p);//Call base class
1433  }
1434  };
1435 
1437 class IOrderOutputParams : public OutputParams
1438 {
1439  virtual int64_t iValue(GravityParticle *p)
1440  {
1441  return p->iOrder;
1442  }
1443  virtual void setIValue(GravityParticle *p, int64_t iValue)
1444  {
1445  p->iOrder = iValue;
1446  }
1447  virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1448  virtual Vector3D<double> vValue(GravityParticle *p)
1449  {CkAssert(0); return 0.0;}
1450  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1451  public:
1452  IOrderOutputParams() {}
1453  IOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1454  bFloat = 0;
1455  bVector = 0;
1456  fileName = _fileName; iBinaryOut = _iBinaryOut;
1457  sTipsyExt = "iord"; sNChilExt = "iord";
1458  dTime = _dTime;
1459  iType = TYPE_GAS | TYPE_DARK | TYPE_STAR; }
1460  PUPable_decl(IOrderOutputParams);
1461  IOrderOutputParams(CkMigrateMessage *m) {}
1462  virtual void pup(PUP::er &p) {
1463  OutputParams::pup(p);//Call base class
1464  }
1465  };
1466 
1468 class IGasOrderOutputParams : public OutputParams
1469 {
1470  virtual int64_t iValue(GravityParticle *p)
1471  {
1472  if(p->isStar())
1473  return p->iGasOrder();
1474  else
1475 #ifdef SPLITGAS
1476  if(p->isGas())
1477  return p->iSplitOrder();
1478  else
1479 #endif
1480  return 0;
1481  }
1482  virtual void setIValue(GravityParticle *p, int64_t iValue)
1483  {
1484  if(p->isStar()) p->iGasOrder() = iValue;
1485  }
1486  virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1487  virtual Vector3D<double> vValue(GravityParticle *p)
1488  {CkAssert(0); return 0.0;}
1489  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1490  public:
1491  IGasOrderOutputParams() {}
1492  IGasOrderOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1493  bFloat = 0;
1494  bVector = 0;
1495  fileName = _fileName; iBinaryOut = _iBinaryOut;
1496  sTipsyExt = "igasorder"; sNChilExt = "igasorder";
1497  dTime = _dTime;
1498  iType = TYPE_STAR; }
1499  PUPable_decl(IGasOrderOutputParams);
1500  IGasOrderOutputParams(CkMigrateMessage *m) {}
1501  virtual void pup(PUP::er &p) {
1502  OutputParams::pup(p);//Call base class
1503  }
1504  };
1505 
1507 class RungOutputParams : public OutputParams
1508 {
1509  virtual int64_t iValue(GravityParticle *p)
1510  {
1511  return p->rung;
1512  }
1513  virtual void setIValue(GravityParticle *p, int64_t iValue)
1514  {
1515  p->rung = iValue;
1516  }
1517  virtual double dValue(GravityParticle *p) {CkAssert(0); return 0.0;}
1518  virtual Vector3D<double> vValue(GravityParticle *p)
1519  {CkAssert(0); return 0.0;}
1520  virtual void setDValue(GravityParticle *p, double val) {CkAssert(0);}
1521  public:
1522  RungOutputParams() {}
1523  RungOutputParams(std::string _fileName, int _iBinaryOut, double _dTime) {
1524  bFloat = 0;
1525  bVector = 0;
1526  fileName = _fileName; iBinaryOut = _iBinaryOut;
1527  sTipsyExt = "rung"; sNChilExt = "rung";
1528  dTime = _dTime;
1529  iType = TYPE_GAS| TYPE_DARK | TYPE_STAR; }
1530  PUPable_decl(RungOutputParams);
1531  RungOutputParams(CkMigrateMessage *m) {}
1532  virtual void pup(PUP::er &p) {
1533  OutputParams::pup(p);//Call base class
1534  }
1535  };
1536 #endif
MetalsOutputParams
Output metal mass fraction.
Definition: InOutput.h:1031
RungOutputParams
Output rungs.
Definition: InOutput.h:1507
VelOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:246
PosOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:215
MuMaxOutputParams
Output artificial viscosity mumax.
Definition: InOutput.h:633
SoftOutputParams
Output particle gravitational softenings.
Definition: InOutput.h:433
OxOutputParams
Output Oxygen mass fraction.
Definition: InOutput.h:969
PosOutputParams
Output particle positions.
Definition: InOutput.h:209
OutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)=0
Input data as an int.
Cool1OutputParams
Output the value in cool_array1.
Definition: InOutput.h:805
ncGetCount
int64_t ncGetCount(std::string typedir)
Definition: InOutput.cpp:430
OutputParams::bFloat
int bFloat
Is a floating point number.
Definition: InOutput.h:33
OutputParams::sTipsyExt
std::string sTipsyExt
Extension for tipsy output.
Definition: InOutput.h:38
PresOutputParams
Output pressure.
Definition: InOutput.h:469
MassOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:191
VelOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:239
AgeOutputParams
Output stellar age (time since formation).
Definition: InOutput.h:1153
GasDenOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:295
AccOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:360
PotOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:268
PosOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:219
iNSIDMOutputParams
Definition: InOutput.h:1399
TempOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:336
DivVOutputParams
Output divergence of velocity.
Definition: InOutput.h:572
MassOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:188
MassOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:192
DenOutputParams
Output densities.
Definition: InOutput.h:384
OutputParams::fileName
std::string fileName
output file
Definition: InOutput.h:37
HsmOutputParams
Output smoothing lengths.
Definition: InOutput.h:409
AccOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:361
AccOutputParams
Output accelerations.
Definition: InOutput.h:357
GravityParticle::iOrder
int64_t iOrder
Input order of particles; unique particle ID.
Definition: GravityParticle.h:328
PosOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:213
PotOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:267
OutputParams::dTime
double dTime
Time of output.
Definition: InOutput.h:36
DtOutputParams
Output timesteps.
Definition: InOutput.h:1308
OutputParams::iBinaryOut
int iBinaryOut
Type of binary output.
Definition: InOutput.h:35
OutputParams::sNChilExt
std::string sNChilExt
file name for NChilada output
Definition: InOutput.h:39
OutputParams
Base class for output parameters.
Definition: InOutput.h:16
OutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > v)
Input data as a Vector3D of doubles.
Definition: InOutput.h:26
TempOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:333
OutputParams::iTypeWriting
unsigned int iTypeWriting
family being written in NC format
Definition: InOutput.h:41
DataManager
Definition: DataManager.h:60
MFormOutputParams
Output mass at formation time.
Definition: InOutput.h:1095
PotOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:272
SoftOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:443
ESNRateOutputParams
Output Supernova heating rate.
Definition: InOutput.h:1277
KeyOutputParams
Output Keys.
Definition: InOutput.h:1343
OutputParams::iValue
virtual int64_t iValue(GravityParticle *p)=0
Output data as an int.
AccOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:363
PotOutputParams
Output particle gravitational potential.
Definition: InOutput.h:264
TempOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:317
VelOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition: InOutput.h:243
VelOutputParams
Output particle velocities.
Definition: InOutput.h:235
OutputParams::iType
unsigned int iType
mask of families containing this attribute
Definition: InOutput.h:40
GasDenOutputParams
Output particle gas density.
Definition: InOutput.h:288
coolontimeOutputParams
Output &quot;cool on time&quot; (time cooling is off until)
Definition: InOutput.h:1248
AccOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:366
TempOutputParams
Output particle gas temperature.
Definition: InOutput.h:312
Cool0OutputParams
Output the value in cool_array0.
Definition: InOutput.h:765
Cool3OutputParams
Output the value in cool_array3.
Definition: InOutput.h:887
TempOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:337
TempOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:335
GasDenOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:292
VelOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:240
AlphaOutputParams
Output variable alpha.
Definition: InOutput.h:500
SoftOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:452
PosOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:212
TimeFormOutputParams
Output formation time.
Definition: InOutput.h:1124
AccOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition: InOutput.h:364
PDVOutputParams
Output pressure times change in volume.
Definition: InOutput.h:602
EDotOutputParams
Output the cooling rate.
Definition: InOutput.h:724
VelOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:245
PosOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:218
IOrderOutputParams
Output iOrder.
Definition: InOutput.h:1437
BSwOutputParams
Output value of Balsara switch.
Definition: InOutput.h:664
GasDenOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:296
DomainOutputParams
Output Domains.
Definition: InOutput.h:1370
OutputParams::setDValue
virtual void setDValue(GravityParticle *p, double d)=0
Input data as a double.
AccOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:367
IronMassFracDotOutputParams
Definition: InOutput.h:1213
MassOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:193
OutputParams::dValue
virtual double dValue(GravityParticle *p)=0
Output data as a double.
OutputParams::dm
DataManager * dm
For extra state information (e.g. cooling)
Definition: InOutput.h:42
TYPETest
int TYPETest(const GravityParticle *a, unsigned int b)
Test for a type flag.
Definition: GravityParticle.h:525
GravityParticle
Fundamental type for a particle.
Definition: GravityParticle.h:316
OutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)=0
Output data as a Vector3D of doubles.
SoftOutputParams::setIValue
virtual void setIValue(GravityParticle *p, int64_t iValue)
Input data as an int.
Definition: InOutput.h:453
PotOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:270
MassOutputParams::vValue
virtual Vector3D< double > vValue(GravityParticle *p)
Output data as a Vector3D of doubles.
Definition: InOutput.h:189
GasDenOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:291
MassOutputParams
Output particle masses.
Definition: InOutput.h:185
GravityParticle::fBall
double fBall
Neighbor search radius for smoothing.
Definition: GravityParticle.h:326
Cool2OutputParams
Output the value in cool_array2.
Definition: InOutput.h:846
SoftOutputParams::dValue
virtual double dValue(GravityParticle *p)
Output data as a double.
Definition: InOutput.h:436
PosOutputParams::setVValue
virtual void setVValue(GravityParticle *p, Vector3D< double > val)
Input data as a Vector3D of doubles.
Definition: InOutput.h:216
CsOutputParams
Output sound speed.
Definition: InOutput.h:694
MetalsDotOutputParams
Definition: InOutput.h:1061
VelOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:242
DvDsOutputParams
Output dvds shock detector.
Definition: InOutput.h:538
GravityParticle::rung
int rung
the current rung (greater means faster)
Definition: GravityParticle.h:329
SoftOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:445
OxygenMassFracDotOutputParams
Definition: InOutput.h:1180
OutputParams::bVector
int bVector
Is a vector, as opposed to a scalar.
Definition: InOutput.h:34
PotOutputParams::iValue
virtual int64_t iValue(GravityParticle *p)
Output data as an int.
Definition: InOutput.h:271
IGasOrderOutputParams
Output iGasOrder.
Definition: InOutput.h:1468
GasDenOutputParams::setDValue
virtual void setDValue(GravityParticle *p, double val)
Input data as a double.
Definition: InOutput.h:294
FeOutputParams
Output Iron mass fraction.
Definition: InOutput.h:1000
Generated by   doxygen 1.8.5