Peano 4
Loading...
Searching...
No Matches
CCZ4.cpp
Go to the documentation of this file.
1#include "CCZ4.h"
3#include <algorithm>
4
5#include "Constants.h"
6
7#include <limits>
8
9#include <stdio.h>
10#include <string.h>
12
13#ifdef IncludeTwoPunctures
15#endif
16
17tarch::logging::Log applications::exahype2::ccz4::CCZ4::_log( "applications::exahype2::ccz4::CCZ4" );
18
19#ifdef IncludeTwoPunctures
20//pre-process, solve the puncture equations
21void applications::exahype2::ccz4::CCZ4::prepare(TP::TwoPunctures* tp){
22 //first we set the parameter. TODO:find a way to read parameter from python script
23 //int swi=0;//0--single black hole, 2--BBH hoc, 2--BBH rotation, 3--GW150914
24 //bbhtype=0 head on, 1-b=3, 2-b=2
25
26 if (CCZ4swi==0){
27 tp->par_b=1.0;
28 tp->center_offset[0]=-1.0; tp->center_offset[1]=0.0; tp->center_offset[2]=0.0;
29 tp->target_M_plus=1.0;//adm mass
30 tp->par_P_plus[0]=0.0; tp->par_P_plus[1]=0.0; tp->par_P_plus[2]=0.0;//linear momentum
31 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=0.0;//spin
32 tp->target_M_minus=0.0;//adm mass
33 tp->par_P_minus[0]=0.0; tp->par_P_minus[1]=0.0; tp->par_P_minus[2]=0.0;//linear momentum
34 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=0.0; //spin
35 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
36 tp->TP_epsilon=1e-6;}
37
38 if (CCZ4swi==4){
39 tp->par_b=1.0;
40 tp->center_offset[0]=-3.0; tp->center_offset[1]=-2.0; tp->center_offset[2]=0.0;
41 tp->target_M_plus=1.0;//adm mass
42 tp->par_P_plus[0]=0.1; tp->par_P_plus[1]=0.1; tp->par_P_plus[2]=0.0;//linear momentum
43 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=0.0;//spin
44 tp->target_M_minus=0.0;//adm mass
45 tp->par_P_minus[0]=0.0; tp->par_P_minus[1]=0.0; tp->par_P_minus[2]=0.0;//linear momentum
46 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=0.0; //spin
47 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
48 tp->TP_epsilon=1e-6;}
49
50 if (CCZ4swi==2 and CCZ4BBHType==0){
51 tp->par_b=2.0;
52 tp->center_offset[0]=0.0; tp->center_offset[1]=0.0; tp->center_offset[2]=0.0;
53 tp->target_M_plus=0.5;//adm mass
54 tp->par_P_plus[0]=0.0; tp->par_P_plus[1]=0.0; tp->par_P_plus[2]=0.0;//linear momentum
55 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=0.0;//spin
56 tp->target_M_minus=0.5;//adm mass
57 tp->par_P_minus[0]=0.0; tp->par_P_minus[1]=0.0; tp->par_P_minus[2]=0.0;//linear momentum
58 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=0.0; //spin
59 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
60 tp->TP_epsilon=1e-6;}
61
62 //following data reference: https://journals.aps.org/prd/pdf/10.1103/PhysRevD.69.024006
63 if (CCZ4swi==2 and CCZ4BBHType==1){
64 tp->par_b=3.0;
65 tp->center_offset[0]=0.0; tp->center_offset[1]=0.0; tp->center_offset[2]=0.0;
66 tp->give_bare_mass=true;//use puncture mass instead of adm mass
67 tp->par_m_plus=0.47656; tp->par_m_minus=0.47656;
68 //tp->target_M_plus=999;//adm mass
69 tp->par_P_plus[0]=0.0; tp->par_P_plus[1]=0.13808; tp->par_P_plus[2]=0.0;//linear momentum
70 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=0.0;//spin
71 //tp->target_M_minus=999;//adm mass
72 tp->par_P_minus[0]=0.0; tp->par_P_minus[1]=-0.13808; tp->par_P_minus[2]=0.0;//linear momentum
73 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=0.0; //spin
74 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
75 tp->TP_epsilon=1e-6;}
76
77 if (CCZ4swi==2 and CCZ4BBHType==2){
78 tp->par_b=2.0;
79 tp->center_offset[0]=0.0; tp->center_offset[1]=0.0; tp->center_offset[2]=0.0;
80 tp->give_bare_mass=true;//use puncture mass instead of adm mass
81 tp->par_m_plus=0.46477; tp->par_m_minus=0.46477;
82 //tp->target_M_plus=999;//adm mass
83 tp->par_P_plus[0]=0.0; tp->par_P_plus[1]=0.19243; tp->par_P_plus[2]=0.0;//linear momentum
84 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=0.0;//spin
85 //tp->target_M_minus=999;//adm mass
86 tp->par_P_minus[0]=0.0; tp->par_P_minus[1]=-0.19243; tp->par_P_minus[2]=0.0;//linear momentum
87 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=0.0; //spin
88 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
89 tp->TP_epsilon=1e-6;}
90
91 if (CCZ4swi==3){
92 double D=10.0, q=36.0/29.0, chip=0.31, chim=-0.46, M=1.0;
93 double Pr=-0.00084541526517121, Pphi=0.09530152296974252;
94 double mp=M*q/(1+q), mm=M*1/(1+q);
95 tp->par_b=5.0;
96 tp->center_offset[0]=D*mm-D/2; tp->center_offset[1]=0.0; tp->center_offset[2]=0.0;
97 tp->target_M_plus=mp;//adm mass
98 tp->par_P_plus[0]=Pr; tp->par_P_plus[1]=Pphi; tp->par_P_plus[2]=0.0;//linear momentum
99 tp->par_S_plus[0]=0.0; tp->par_S_plus[1]=0.0; tp->par_S_plus[2]=chip*mp*mp;//spin
100 tp->target_M_minus=1/(1+q);//adm mass
101 tp->par_P_minus[0]=-Pr; tp->par_P_minus[1]=-Pphi; tp->par_P_minus[2]=0.0;//linear momentum
102 tp->par_S_minus[0]=0.0; tp->par_S_minus[1]=0.0; tp->par_S_minus[2]=chim*mm*mm; //spin
103 tp->grid_setup_method="evaluation"; //evaluation or Taylor expansion
104 tp->TP_epsilon=1e-6;}
105 tp->PrintParameters();
106
107 //then solve the equation
108 tp->Run();
109}
110#endif
111
113 if ( Scenario==0 || Scenario==1 ) {
114 const char* name = "GaugeWave";//nothing to do here for now
115 int length = strlen(name);
116 //initparameters_(&length, name);
117 }
118 #ifdef IncludeTwoPunctures
119 if ( Scenario==2 ) {
120 prepare(_tp);//we solve the puncture equation here.
121 //exit(0);
122 }
123 #endif
124 else {
125 //std::cerr << "initial scenario " << Scenario << " is not supported" << std::endl << std::endl << std::endl;
126 }
127}
128
130 double * __restrict__ Q,
133 bool gridIsConstructed
134) {
135 logTraceInWith3Arguments( "initialCondition(...)", volumeX, volumeH, gridIsConstructed );
136
137 if ( Scenario==0 ) {
139 }
140 else if ( Scenario==3 ) {
142 }
143 else if ( Scenario==1 ) {
145 }
146 else if ( Scenario==4 ) {
148 }
149 #ifdef IncludeTwoPunctures
150 else if ( Scenario==2 ) {
151
152 // We use the bool to trigger the hgh res interpolation once the grid is constructed
153 applications::exahype2::ccz4::ApplyTwoPunctures(Q, volumeX, 0, _tp, not gridIsConstructed); //we interpolate for real IC here.
154 }
155 #endif
156 else {
157 logError( "initialCondition(...)", "initial scenario " << Scenario << " is not supported" );
158 }
159
160 for (int i=0; i<NumberOfUnknowns; i++) {
161 assertion2( std::isfinite(Q[i]), volumeX, i );
162 }
163
164 for (int i=NumberOfUnknowns; i<NumberOfUnknowns+NumberOfAuxiliaryVariables; i++) {
165 Q[i] = 0.0;
166 }
167
168
169/*
170 else {
171 enforceCCZ4constraints(Q);
172 }
173*/
174 logTraceOut( "initialCondition(...)" );
175}
176
177
179 const double * __restrict__ Q, // Q[59+0]
182 double t,
183 double dt,
184 double * __restrict__ S // S[59
185) {
186#if !defined(GPUOffloadingOMP)
187 logTraceInWith4Arguments( "sourceTerm(...)", volumeX, volumeH, t, dt );
188 for(int i=0; i<NumberOfUnknowns; i++){
189 assertion3( std::isfinite(Q[i]), i, volumeX, t );
190 }
191#endif
192 // for (int i=NumberOfUnknowns; i<NumberOfUnknowns+NumberOfAuxiliaryVariables; i++) {
193 // S[i] = 0.0;
194 //}
195 applications::exahype2::ccz4::CCZ4::sourceTerm(Q, volumeX, volumeH, t, dt, S, Offloadable::Yes);
196 /*
197 if (CCZ4smoothing>0){// then we apply simple laplacian smoothing
198 constexpr int NumberOfRefinementLayers = 3;
199 double Radius[NumberOfRefinementLayers] = {5.0*1.8, 3.0*1.8, 1.5*1.8};
200 double radius=volumeX(0)*volumeX(0)+volumeX(1)*volumeX(1)+volumeX(2)*volumeX(2); radius=pow(radius,0.5);
201 ::exahype2::CellAccess access(
202 Q, // make it initially point to input
203 1, // halo size, which you know as user
204 NumberOfUnknowns, // defined in superclass
205 NumberOfAuxiliaryVariables // defined in superclass
206 NumberOfDoFsPerAxisInCell, // defined in superclass
207 );
208 double laplacian=0.0;
209 for (int unknown=0; unknown<NumberOfUnknowns; unknown++) {
210 laplacian = -6.0 * access.centre(unknown)
211 + 1.0 * access.left(0,unknown)+ 1.0 * access.right(0,unknown)
212 + 1.0 * access.left(1,unknown)+ 1.0 * access.right(1,unknown)
213 + 1.0 * access.left(2,unknown)+ 1.0 * access.right(2,unknown);
214 laplacian /= volumeH(0);
215 laplacian /= volumeH(0);
216 double coef=CCZ4smoothing*(std::exp(-5.0*std::abs(radius-Radius[0])) + std::exp(-5.0*std::abs(radius-Radius[1])) + std::exp(-5.0*std::abs(radius-Radius[2])) )/3.0;
217 coef=CCZ4smoothing;
218 S[unknown]+=coef*laplacian;
219 }
220 }*/
221
222#if !defined(GPUOffloadingOMP)
223 for(int i=0; i<NumberOfUnknowns; i++){
224 nonCriticalAssertion3( std::isfinite(S[i]), i, volumeX, t );
225 }
226 logTraceOut( "sourceTerm(...)" );
227#endif
228}
229
230
232 const double * __restrict__ Qinside, // Qinside[59+0]
233 double * __restrict__ Qoutside, // Qoutside[59+0]
234 const tarch::la::Vector<Dimensions,double>& faceCentre,
236 double t,
237 int normal
238) {
239 logTraceInWith4Arguments( "boundaryConditions(...)", faceCentre, volumeH, t, normal );
240 for(int i=0; i<NumberOfUnknowns+NumberOfAuxiliaryVariables; i++) {
241 assertion4( Qinside[i]==Qinside[i], faceCentre, t, normal, i );
242 Qoutside[i]=Qinside[i];
243 }
244 logTraceOut( "boundaryConditions(...)" );
245}
246
247
249 const double * __restrict__ Q, // Q[59+0],
250 const tarch::la::Vector<Dimensions,double>& faceCentre,
252 double t,
253 double dt,
254 int normal
255)
256{
257 return maxEigenvalue(Q, faceCentre, volumeH, t, dt, normal, Offloadable::Yes);
258}
259
260
262 const double * __restrict__ Q, // Q[59+0],
263 const double * __restrict__ deltaQ, // [59+0]
264 const tarch::la::Vector<Dimensions,double>& faceCentre,
266 double t,
267 double dt,
268 int normal,
269 double * __restrict__ BgradQ // BgradQ[59]
270) {
271#if !defined(GPUOffloadingOMP)
272 logTraceInWith4Arguments( "nonconservativeProduct(...)", faceCentre, volumeH, t, normal );
273 assertion( normal>=0 );
274 assertion( normal<Dimensions );
275#endif
276 nonconservativeProduct(Q, deltaQ, faceCentre, volumeH, t, dt, normal, BgradQ, Offloadable::Yes);
277
278#if !defined(GPUOffloadingOMP)
279 for (int i=0; i<NumberOfUnknowns; i++) {
280 nonCriticalAssertion4( std::isfinite(BgradQ[i]), i, faceCentre, t, normal );
281 }
282 logTraceOut( "nonconservativeProduct(...)" );
283#endif
284}
285
286#if defined(GPUOffloadingOMP)
287#pragma omp declare target
288#endif
290 const double * __restrict__ Q, // Q[59+0],
291 const double * __restrict__ deltaQ, // [59+0]
292 const tarch::la::Vector<Dimensions,double>& faceCentre,
294 double t,
295 double dt,
296 int normal,
297 double * __restrict__ BgradQ, // BgradQ[59]
298 Offloadable
299)
300{
301 double gradQSerialised[NumberOfUnknowns*3];
302 for (int i=0; i<NumberOfUnknowns; i++) {
303 gradQSerialised[i+0*NumberOfUnknowns] = 0.0;
304 gradQSerialised[i+1*NumberOfUnknowns] = 0.0;
305 gradQSerialised[i+2*NumberOfUnknowns] = 0.0;
306
307 gradQSerialised[i+normal*NumberOfUnknowns] = deltaQ[i];
308 }
309 //for (int i=NumberOfUnknowns; i<NumberOfUnknowns+NumberOfAuxiliaryVariables; i++) {
310 // BgradQ[i] = 0.0;
311 //}
312 ncp(BgradQ, Q, gradQSerialised, normal, CCZ4LapseType, CCZ4ds, CCZ4c, CCZ4e, CCZ4f, CCZ4bs, CCZ4sk, CCZ4xi, CCZ4mu, CCZ4SO);
313}
314#if defined(GPUOffloadingOMP)
315#pragma omp end declare target
316#endif
317
319 const double * __restrict__ Q,
320 const tarch::la::Vector<Dimensions,double>& volumeCentre,
322 double t
323) {
325
326 const double radius = tarch::la::norm2( volumeCentre );
327 //
328 // see documentation in header file
329 //
330 if (CCZ4ReSwi==1) { //radius based
331 if (radius<0.1) {
333 }
334 }
335 if (CCZ4ReSwi==2) { //
336 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
337 constexpr int NumberOfRefinementLayers = 2;
338// current "standard" refinement pattern
339 double Radius[NumberOfRefinementLayers] = {4, 2.5};
340 double MaxH[NumberOfRefinementLayers] = {0.15,0.04};
342 for (int i=0; i<NumberOfRefinementLayers; i++) {
343 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
345 }
346 }
347 }
348 }
349 if (CCZ4ReSwi==3) { //binary black holes
350 //double radius1=(volumeCentre(0)-4.251)*(volumeCentre(0)-4.251)+volumeCentre(1)*volumeCentre(1)+volumeCentre(2)*volumeCentre(2);
351 //double radius2=(volumeCentre(0)+4.251)*(volumeCentre(0)+4.251)+volumeCentre(1)*volumeCentre(1)+volumeCentre(2)*volumeCentre(2);
352
353 tarch::la::Vector<Dimensions,double> leftBH = {-4.241, 0.0, 0.0};
354 tarch::la::Vector<Dimensions,double> rightBH = { 4.241, 0.0, 0.0};
355
356 const double radius1 = tarch::la::norm2( volumeCentre - leftBH );
357 const double radius2 = tarch::la::norm2( volumeCentre - rightBH );
358
359 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
360 if ( ((radius1<5) or (radius2<5)) and (volumeH(0)>1.0)) { result=::exahype2::RefinementCommand::Refine; }
361 else if ((radius1<2.5) or (radius2<2.5)) { result=::exahype2::RefinementCommand::Refine; }
363 } else {
364 if ((Q[65]>0.1) and (volumeH(0)>1.0)) { result=::exahype2::RefinementCommand::Refine; }
365 else if (Q[65]>0.2) { result=::exahype2::RefinementCommand::Refine; }
367 }
368 }
369 if (CCZ4ReSwi==4){ //single black hole, higher level of amr
370 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
371 constexpr int NumberOfRefinementLayers = 4;
372 // with some alter
373 double Radius[NumberOfRefinementLayers] = {5.0, 3.0, 1.5, 0.5};
374 double MaxH[NumberOfRefinementLayers] = {0.3, 0.15, 0.04, 0.01};
375
377 for (int i=0; i<NumberOfRefinementLayers; i++) {
378 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
380 }
381 }
382 }
383 }
384 if (CCZ4ReSwi==8){ //single black hole, higher level of amr
385 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
386 constexpr int NumberOfRefinementLayers = 1;
387 double Radius[NumberOfRefinementLayers] = {2};
388 double MaxH[NumberOfRefinementLayers] = {0.04};
389
391 for (int i=0; i<NumberOfRefinementLayers; i++) {
392 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
394 }
395 }
396 }
397 }
398 if (CCZ4ReSwi==5){ //single black hole, decent refinement
399 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
400 constexpr int NumberOfRefinementLayers = 3;
401// current "standard" refinement pattern
402 double Radius[NumberOfRefinementLayers] = {3.0, 1.0, 0.5};
403 double MaxH[NumberOfRefinementLayers] = {0.2, 0.06, 0.02};
404// with some alter
405// double Radius[NumberOfRefinementLayers] = {5.0, 3.0};
406// double MaxH[NumberOfRefinementLayers] = {0.3, 0.15};
407
409 for (int i=0; i<NumberOfRefinementLayers; i++) {
410 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
412 }
413 }
414 }
415 }
416 if (CCZ4ReSwi==6){
417 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
418 constexpr int NumberOfRefinementLayers = 2;
419 double Radius[NumberOfRefinementLayers] = {4, 3};
420 double MaxH[NumberOfRefinementLayers] = {0.15,0.04};
421
423 for (int i=0; i<NumberOfRefinementLayers; i++) {
424 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
426 }
427 }
428 }
429 }
430 if (CCZ4ReSwi==7){
431 if (tarch::la::equals(t,0.0)){ //as we use a quantity calculated in postpocessing, we need to provide criterion at the first timestep
432 constexpr int NumberOfRefinementLayers = 2;
433 double Radius[NumberOfRefinementLayers] = {3.0, 1.5};
434 double MaxH[NumberOfRefinementLayers] = {0.15,0.04};
436 for (int i=0; i<NumberOfRefinementLayers; i++) {
437 if (radius<Radius[i] and tarch::la::max(volumeH)>MaxH[i]) {
439 }
440 }
441 }
442 }
443 return result;
444}
445
#define assertion2(expr, param0, param1)
#define assertion4(expr, param0, param1, param2, param3)
#define assertion3(expr, param0, param1, param2)
#define assertion(expr)
#define logError(methodName, logMacroMessageStream)
Wrapper macro around tarch::tarch::logging::Log to improve logging.
Definition Log.h:464
#define logTraceOut(methodName)
Definition Log.h:379
#define logTraceInWith4Arguments(methodName, argument0, argument1, argument2, argument3)
Definition Log.h:373
#define logTraceInWith3Arguments(methodName, argument0, argument1, argument2)
Definition Log.h:372
#define nonCriticalAssertion3(expr, param0, param1, param2)
#define nonCriticalAssertion4(expr, param0, param1, param2, param3)
virtual void boundaryConditions(const double *__restrict__ Qinside, double *__restrict__ Qoutside, const tarch::la::Vector< Dimensions, double > &faceCentre, const tarch::la::Vector< Dimensions, double > &volumeH, double t, int normal) override
Definition CCZ4.cpp:231
virtual double maxEigenvalue(const double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &faceCentre, const tarch::la::Vector< Dimensions, double > &volumeH, double t, double dt, int normal) override
Determine max eigenvalue over Jacobian in a given point with solution values (states) Q.
Definition CCZ4.cpp:248
virtual void nonconservativeProduct(const double *__restrict__ Q, const double *__restrict__ deltaQ, const tarch::la::Vector< Dimensions, double > &faceCentre, const tarch::la::Vector< Dimensions, double > &volumeH, double t, double dt, int normal, double *__restrict__ BgradQ) override
Definition CCZ4.cpp:261
static tarch::logging::Log _log
Definition CCZ4.h:32
::exahype2::RefinementCommand refinementCriterion(const double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &volumeCentre, const tarch::la::Vector< Dimensions, double > &volumeH, double t) override
Refinement criterion.
Definition CCZ4.cpp:318
void sourceTerm(const double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &volumeCentre, const tarch::la::Vector< Dimensions, double > &volumeH, double t, double dt, double *__restrict__ S) override
Definition CCZ4.cpp:178
void initialCondition(double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &volumeCentre, const tarch::la::Vector< Dimensions, double > &volumeH, bool gridIsConstructed) override
Definition CCZ4.cpp:129
Log Device.
Definition Log.h:516
void linearWave(double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &X, double t)
void diagonal_gaugeWave(double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &x, double t)
void flat(double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &X, double t)
KeywordToAvoidDuplicateSymbolsForInlinedFunctions double maxEigenvalue(const double *const Q, int normal, const double CCZ4e, const double CCZ4ds, const double CCZ4GLMc, const double CCZ4GLMd) InlineMethod
KeywordToAvoidDuplicateSymbolsForInlinedFunctions void ncp(double *BgradQ, const double *const Q, const double *const gradQSerialised, const int normal, const int CCZ4LapseType, const double CCZ4ds, const double CCZ4c, const double CCZ4e, const double CCZ4f, const double CCZ4bs, const double CCZ4sk, const double CCZ4xi, const double CCZ4mu, const double CCZ4SO) InlineMethod
void gaugeWave(double *__restrict__ Q, const tarch::la::Vector< Dimensions, double > &x, double t)
float M
Definition csv_plot.py:10
double max(double a, double b, double c)
I need the maximum of three values all the time, to I decided to write a function for this.
Definition Scalar.cpp:8
bool equals(const Matrix< Rows, Cols, Scalar > &lhs, const Matrix< Rows, Cols, Scalar > &rhs, const Scalar &tolerance=NUMERICAL_ZERO_DIFFERENCE)
Compares to matrices on equality by means of a numerical accuracy.
Scalar norm2(const Vector< Size, Scalar > &vector)
Computes the 2-norm of the vector, i.e.
double par_S_plus[3]
std::string grid_setup_method
double par_P_plus[3]
double par_S_minus[3]
double center_offset[3]
double target_M_minus
double par_P_minus[3]
Simple vector class.
Definition Vector.h:134