changa  3.5
 All Classes Files Functions Variables Typedefs Enumerations Friends Macros Groups Pages
feedback.h
1 #ifndef FEEDBACK_HINCLUDED
2 #define FEEDBACK_HINCLUDED
3 
4 #include "parameters.h"
5 #include "supernova.h"
6 #include "imf.h"
7 #include "starlifetime.h"
8 #define NFEEDBACKS 5
9 
13 class FBEffects {
14  public:
15  double dEnergy; /* Energy produced per mass (ergs/gm); note that
16  this might need to be divided up
17  into different forms of energy. */
18  double dMassLoss; /* Mass lost in Solar Masses */
19  double dMetals; /* Fraction of the mass lost in
20  elements heavier than Helium */
21  double dMIron; /* Solar masses of iron ejected */
22  double dMOxygen; /* Solar masses of oxygen ejected */
23  FBEffects() : dEnergy(0), dMassLoss(0), dMetals(0), dMIron(0), dMOxygen(0) { }
24  FBEffects(double dEnergy, double dMassLoss, double dMetals, double dMIron, double dMOxygen) :
25  dEnergy(dEnergy), dMassLoss(dMassLoss), dMetals(dMetals), dMIron(dMIron), dMOxygen(dMOxygen) { }
26  };
27 
32 class SFEvent {
33  public:
34  double dMass; /* mass in star formation event in solar masses */
35  double dTimeForm; /* time of star formation event in years */
36  double dMetals; /* metallicity of stars in event */
37  double dMFracOxygen; /* metallicity of stars in event */
38  double dMFracIron; /* metallicity of stars in event */
39  SFEvent() : dMass(0), dTimeForm(0), dMetals(0), dMFracIron(0), dMFracOxygen(0) { }
40  SFEvent(double mass, double tform, double mets, double fefrac, double oxfrac) :
41  dMass(mass), dTimeForm(tform), dMetals(mets), dMFracIron(fefrac), dMFracOxygen(oxfrac) { }
42  };
43 
45 class Fdbk : public PUP::able {
46  private:
47  Fdbk& operator=(const Fdbk& fb);
48  void CalcWindFeedback(SFEvent *sfEvent, double dTime,
49  double dDelta, FBEffects *fbEffects) const;
50  void CalcUVFeedback(SFEvent *sfEvent, double dTime, double dDelta,
51  FBEffects *fbEffects) const;
52 #ifdef COOLING_MOLECULARH
53  double CalcLWFeedback(SFEvent *sfEvent, double dTime, double dDelta) const;
54 #endif /*COOLING_MOLECULARH*/
55 
56  char achIMF[32]; /* initial mass function */
57  int iRandomSeed; /* seed for stochastic quantized feedback */
58  double dGmUnit; /* system mass in grams */
59  double dGmPerCcUnit; /* system density in gm/cc */
60  double dErgUnit; /* system energy in ergs */
61  Padova pdva;
62  public:
63  mutable SN sn;
64  double dDeltaStarForm;
65  double dErgPerGmUnit; /* system specific energy in ergs/gm */
66  double dSecUnit; /* system time in seconds */
67  double dMaxGasMass; /* Maximum mass of a gas particle */
68 #ifdef SPLITGAS
69  double dInitGasMass; /* Original mass of a gas particle */
70 #endif
71  int bSNTurnOffCooling; /* turn off cooling or not */
72  int bSmallSNSmooth; /* smooth SN energy only over blast radius */
73  int bShortCoolShutoff; /* use snowplow time */
74  int bAGORAFeedback; /* Replace stellar feedback with AGORA perscription */
75  double dExtraCoolShutoff; /* multiplicative factor for shutoff time */
76  double dRadPreFactor; /* McKee + Ostriker size constant in system units */
77  double dTimePreFactor; /* McKee + Ostriker time constant in system units */
78  int nSmoothFeedback; /* number of particles to smooth feedback over*/
79  double dMaxCoolShutoff; /* Maximum length of time to shutoff cooling */
80  double dEarlyFeedbackFrac; /* Fraction of SNe II to put in early feedback */
81  double dFBInitialMassLoad; /* Initial Mass Loading in Superbubble feedback*/
82  double dMultiPhaseMinTemp;
83  double dMultiPhaseMaxTime;
84  double dEarlyETotal; /* Total E in early FB per solar mass of stars */
85  IMF *imf;
86 
87  void AddParams(PRM prm);
88  void CheckParams(PRM prm, struct parameters &param);
89  void NullFeedback() { imf = new Kroupa01(); } /* Place holder */
90  void DoFeedback(GravityParticle *p, double dTime, double dDeltaYr,
91  FBEffects *fbTotals) const;
92  double NSNIa (double dMassT1, double dMassT2);
93  Fdbk() { }
94 
95  PUPable_decl(Fdbk);
96  Fdbk(const Fdbk& fb);
97  Fdbk(CkMigrateMessage *m) : PUP::able(m) {}
98  ~Fdbk() {
99  delete imf;
100  }
101  inline void pup(PUP::er &p);
102  };
103 
104 // "Deep copy" constructer is need because of imf pointer.
105 inline Fdbk::Fdbk(const Fdbk& fb) {
106  strcpy(achIMF, fb.achIMF);
107  dDeltaStarForm = fb.dDeltaStarForm;
108  dErgPerGmUnit = fb.dErgPerGmUnit;
109  dGmUnit = fb.dGmUnit;
110  dGmPerCcUnit = fb.dGmPerCcUnit;
111  dErgUnit = fb.dErgUnit;
112  dSecUnit = fb.dSecUnit;
113  dMaxGasMass = fb.dMaxGasMass;
114 #ifdef SPLITGAS
115  dInitGasMass = fb.dInitGasMass;
116 #endif
117  bSNTurnOffCooling = fb.bSNTurnOffCooling;
118  bSmallSNSmooth = fb.bSmallSNSmooth;
119  bShortCoolShutoff = fb.bShortCoolShutoff;
120  bAGORAFeedback = fb.bAGORAFeedback;
121  dExtraCoolShutoff = fb.dExtraCoolShutoff;
122  dRadPreFactor = fb.dRadPreFactor;
123  dTimePreFactor = fb.dTimePreFactor;
124  nSmoothFeedback = fb.nSmoothFeedback;
125  dMaxCoolShutoff = fb.dMaxCoolShutoff;
126  dEarlyFeedbackFrac = fb.dEarlyFeedbackFrac;
127  dFBInitialMassLoad = fb.dFBInitialMassLoad;
128  dMultiPhaseMinTemp = fb.dMultiPhaseMinTemp;
129  dMultiPhaseMaxTime = fb.dMultiPhaseMaxTime;
130  dEarlyETotal = fb.dEarlyETotal;
131  sn = fb.sn;
132  pdva = fb.pdva;
133  imf = fb.imf->clone();
134 }
135 
136 inline void Fdbk::pup(PUP::er &p) {
137  p(achIMF, 32);
138  p | dDeltaStarForm;
139  p | dErgPerGmUnit;
140  p | dGmUnit;
141  p | dGmPerCcUnit;
142  p | dErgUnit;
143  p | dSecUnit;
144  p | dMaxGasMass;
145 #ifdef SPLITGAS
146  p | dInitGasMass;
147 #endif
148  p | bSNTurnOffCooling;
149  p | bSmallSNSmooth;
150  p | bShortCoolShutoff;
151  p | bAGORAFeedback;
152  p | dExtraCoolShutoff;
153  p | dRadPreFactor;
154  p | dTimePreFactor;
155  p | nSmoothFeedback;
156  p | dMaxCoolShutoff;
157  p | dEarlyFeedbackFrac;
158  p | dFBInitialMassLoad;
159  p | dMultiPhaseMinTemp;
160  p | dMultiPhaseMaxTime;
161  p | dEarlyETotal;
162  p | sn;
163  p | pdva;
164  p | imf;
165  }
166 
167 enum FBenum{
168  FB_SNII=0,
169  FB_SNIA,
170  FB_WIND,
171  FB_UV,
172  FB_AGORA
173 };
174 
175 #include "smoothparams.h"
176 
182 class AGORApreCheckSmoothParams : public SmoothParams
183 {
184  double dTime, dDelta, H, a, gamma, etaCourant, timeToSF, dMsolUnit, dErgPerGmUnit;
185  Fdbk fb;
186  virtual void fcnSmooth(GravityParticle *p, int nSmooth,
187  pqSmoothNode *nList);
188  virtual int isSmoothActive(GravityParticle *p) { return p->isStar(); }
189  virtual void initSmoothParticle(GravityParticle *p) {}
190  virtual void initTreeParticle(GravityParticle *p) {}
191  virtual void postTreeParticle(GravityParticle *p) {}
192  virtual void initSmoothCache(GravityParticle *p);
193  virtual void combSmoothCache(GravityParticle *p1,
194  ExternalSmoothParticle *p2);
195  void DistFBMME(GravityParticle *p, int nSmooth, pqSmoothNode *nList);
196  public:
197  AGORApreCheckSmoothParams() {}
198  AGORApreCheckSmoothParams(int _iType, int am, CSM csm, double _dTime, double _dDelta,
199  double _gamma, double _etaCourant, double _timeToSF, Fdbk *feedback,
200  double _dMsolUnit, double _dErgPerGmUnit) :
201  fb (*feedback) {
202  iType = _iType;
203  activeRung = am;
204  bUseBallMax = 0;
205  gamma = _gamma;
206  etaCourant = _etaCourant;
207  timeToSF = _timeToSF;
208  dMsolUnit = _dMsolUnit;
209  dErgPerGmUnit = _dErgPerGmUnit;
210  dTime = _dTime;
211  dDelta = _dDelta;
212  if(csm->bComove) {
213  H = csmTime2Hub(csm,dTime);
214  a = csmTime2Exp(csm,dTime);
215  }
216  else {
217  H = 0.0;
218  a = 1.0;
219  }
220  }
221  PUPable_decl(AGORApreCheckSmoothParams);
222  AGORApreCheckSmoothParams(CkMigrateMessage *m) : SmoothParams(m) {}
223  virtual void pup(PUP::er &p) {
224  SmoothParams::pup(p);
225  p|a;
226  p|H;
227  p|gamma;
228  p|etaCourant;
229  p|timeToSF;
230  p|dMsolUnit;
231  p|dErgPerGmUnit;
232  p|fb;
233  p|dTime;
234  p|dDelta;
235  }
236  };
237 
243 class DistStellarFeedbackSmoothParams : public SmoothParams
244 {
245  double dTime, H, a, gamma;
246  Fdbk fb;
247  virtual void fcnSmooth(GravityParticle *p, int nSmooth,
248  pqSmoothNode *nList);
249  virtual int isSmoothActive(GravityParticle *p);
250  virtual void initSmoothParticle(GravityParticle *p) {}
251  virtual void initTreeParticle(GravityParticle *p);
252  virtual void postTreeParticle(GravityParticle *p);
253  virtual void initSmoothCache(GravityParticle *p);
254  virtual void combSmoothCache(GravityParticle *p1,
255  ExternalSmoothParticle *p2);
256  void DistFBMME(GravityParticle *p, int nSmooth, pqSmoothNode *nList);
257  public:
258  DistStellarFeedbackSmoothParams() {}
259  DistStellarFeedbackSmoothParams(int _iType, int am, CSM csm, double _dTime,
260  double _gamma, Fdbk *feedback) :
261  fb (*feedback) {
262  iType = _iType;
263  activeRung = am;
264  bUseBallMax = 0;
265  gamma = _gamma;
266  dTime = _dTime;
267  if(csm->bComove) {
268  H = csmTime2Hub(csm,dTime);
269  a = csmTime2Exp(csm,dTime);
270  }
271  else {
272  H = 0.0;
273  a = 1.0;
274  }
275  }
276  /* ~DistStellarFeedbackSmoothParams() {
277  delete fb;
278  }*/
279  PUPable_decl(DistStellarFeedbackSmoothParams);
280  DistStellarFeedbackSmoothParams(CkMigrateMessage *m) : SmoothParams(m) {}
281  virtual void pup(PUP::er &p) {
282  SmoothParams::pup(p);//Call base class
283  p|a;
284  p|H;
285  p|gamma;
286  p|fb;
287  p|dTime;
288  }
289  };
290 
291 #endif
292 
293 
ExternalSmoothParticle
Class for cross processor data needed for smooth operations.
Definition: GravityParticle.h:568
Fdbk::AddParams
void AddParams(PRM prm)
initialize parameters for star formation
Definition: feedback.cpp:26
parameters
Hold parameters of the run.
Definition: parameters.h:14
AGORApreCheckSmoothParams::pup
virtual void pup(PUP::er &p)
required method for remote entry call.
Definition: feedback.h:223
AGORApreCheckSmoothParams
Definition: feedback.h:182
SmoothParams::bUseBallMax
int bUseBallMax
Definition: smoothparams.h:14
DistStellarFeedbackSmoothParams
Definition: feedback.h:243
prmContext
Object containing the parameter information.
Definition: param.h:38
Fdbk::CheckParams
void CheckParams(PRM prm, struct parameters &param)
Definition: feedback.cpp:102
IMF
Interface class for initial mass function.
Definition: imf.h:15
csmContext
Cosmological parameters.
Definition: cosmo.h:10
SmoothParams::iType
int iType
Particle type to smooth over; "TreeActive".
Definition: smoothparams.h:11
pqSmoothNode
Object for priority queue entry.
Definition: smooth.h:12
Fdbk::DoFeedback
void DoFeedback(GravityParticle *p, double dTime, double dDeltaYr, FBEffects *fbTotals) const
Fdbk main method.
Definition: feedback.cpp:420
SmoothParams::pup
virtual void pup(PUP::er &p)
required method for remote entry call.
Definition: smoothparams.h:45
IMF::clone
virtual IMF * clone() const =0
copy IMF object
Fdbk
Stellar/Supernova feedback parameters and routines.
Definition: feedback.h:45
SmoothParams
A base class from which parameters for all smooth operations can be derived.
Definition: smoothparams.h:8
SN
Methods for calculating the number and feedback effects of supernova.
Definition: supernova.h:11
SFEvent
Definition: feedback.h:32
Padova
routines to calculate stellar lifetimes as a function of mass and metalicity.
Definition: starlifetime.h:27
DistStellarFeedbackSmoothParams::pup
virtual void pup(PUP::er &p)
required method for remote entry call.
Definition: feedback.h:281
Kroupa01
Implement IMF from Kroupa 2001.
Definition: imf.h:125
SmoothParams::activeRung
int activeRung
Currently active rung.
Definition: smoothparams.h:12
GravityParticle
Fundamental type for a particle.
Definition: GravityParticle.h:316
FBEffects
Class to return feedback effects.
Definition: feedback.h:13
Generated by   doxygen 1.8.5