22 std::cout <<
"TestEulerKernels.." << std::endl;
28 std::vector<bool> dimComputeDV(2,
true);
29 std::vector<bool> dimUniformGridMetric(2,
true);
30 std::vector<bool> dimEulerRHS(2,
true);
31 std::vector<bool> dimUniformFlux(2,
true);
33 for(
int nDim = 2;nDim <= 3;nDim++){
40 realGridExtent.resize(numDim*2,0.0);
41 for(
int iDim = 0;iDim < numDim;iDim++)
42 realGridExtent[iDim*2 + 1] = 1.0;
45 std::vector<size_t> &numNodes(testGrid.
GridSizes());
46 numNodes.resize(numDim);
56 size_t numNodesDomain = 1;
57 size_t numCellsDomain = 1;
58 std::vector<double> dX(numDim,0.0);
61 for(
int iDim = 0;iDim < numDim;iDim++){
62 numNodesDomain *= numNodes[iDim];
63 numCellsDomain *= (numNodes[iDim]-1);
64 dX[iDim] = (realGridExtent[iDim*2+1] - realGridExtent[iDim*2])/(numNodes[iDim]-1);
65 gridMetric[iDim] = 1.0/dX[iDim];
69 std::cout <<
"Grid finalization failed." << std::endl;
92 double specGasConst = 1.0;
95 std::vector<double> vVec(numDim,0.0);
101 std::vector<double> expectedRhoM1(numNodesDomain,1.0);
102 std::vector<double> expectedFlux((numDim+2)*numNodesDomain,0.0);
103 std::vector<double> expectedPressure(numNodesDomain,1.0);
104 std::vector<double> expectedTemperature(numNodesDomain,1.0);
105 std::vector<double> expectedVHat(numDim*numNodesDomain,0.0);
106 std::vector<double> expectedVelocity(numDim*numNodesDomain,0.0);
107 std::vector<double> expectedInternalEnergy(numNodesDomain,1.0/(gamma-1.0));
108 std::vector<double> expectedRHS((numDim+2)*numNodesDomain,0.0);
110 std::vector<double> ke(numNodesDomain,0.0);
111 std::vector<double> rho(numNodesDomain,1.0);
112 std::vector<double> rhoV(numDim*numNodesDomain,1.0);
113 std::vector<double> rhoE(numNodesDomain,0.0);
118 for(
int iDim = 0;iDim < numDim;iDim++){
119 for(
int iPoint = 0;iPoint < numNodesDomain;iPoint++){
120 rhoV[iDim*numNodesDomain + iPoint] = rho[iPoint]*vVec[iDim];
121 ke[iPoint] += .5*rho[iPoint]*vVec[iDim]*vVec[iDim];
122 expectedVelocity[iDim*numNodesDomain+iPoint] = vVec[iDim];
123 expectedVHat[iDim*numNodesDomain+iPoint] = vVec[iDim]/dX[iDim];
127 for(
int iPoint = 0;iPoint < numNodesDomain;iPoint++){
128 rhoE[iPoint] = 1.0/(gamma-1.0) + ke[iPoint];
131 std::vector<double> T(numNodesDomain,0.0);
132 std::vector<double> p(numNodesDomain,0.0);
133 std::vector<double> rhom1(numNodesDomain,0.0);
134 std::vector<double>
velocity(numDim*numNodesDomain,-.1);
135 std::vector<double> internalEnergy(numNodesDomain,0.);
138 std::vector<double *> vBuffers(numDim,(
double *)NULL);
139 for(
int iDim = 0;iDim < numDim;iDim++)
140 vBuffers[iDim] = &velocity[iDim*numNodesDomain];
142 std::vector<double *> myStateBuffers(numDim+2,NULL);
143 myStateBuffers[0] = &rho[0];
144 for(
int iDim = 0;iDim < numDim;iDim++)
145 myStateBuffers[iDim+1] = &rhoV[iDim*numNodesDomain];
146 myStateBuffers[numDim+1] = &rhoE[0];
148 std::vector<double *> myDVBuffers(4+numDim,NULL);
149 myDVBuffers[0] = &p[0];
150 myDVBuffers[1] = &T[0];
151 myDVBuffers[2] = &rhom1[0];
153 for(
int iDim = 0;iDim < numDim;iDim++){
154 vBuffers[iDim] = &velocity[iDim*numNodesDomain];
155 myDVBuffers[3+iDim] = vBuffers[iDim];
157 myDVBuffers[numDim+3] = &internalEnergy[0];
174 std::cout <<
"Failed to initialize EOS" << std::endl;
179 std::cout <<
"ComputeDVBuffer failed." << std::endl;
184 std::cout <<
"ComputePressure failed." << std::endl;
188 std::cout <<
"ComputeTemperature failed." << std::endl;
191 bool computeDVWorks =
true;
192 bool pfailed =
false;
193 bool tfailed =
false;
194 bool rfailed =
false;
195 bool vfailed =
false;
196 bool efailed =
false;
198 for(
int iNode = 0;iNode < numNodesDomain;iNode++){
199 if(std::abs(p[iNode] - expectedPressure[iNode]) > 1e-15){
200 computeDVWorks =
false;
203 if(std::abs(T[iNode] - expectedTemperature[iNode]) > 1e-15){
204 computeDVWorks =
false;
207 if(std::abs(rhom1[iNode] - expectedRhoM1[iNode]) > 1e-15){
208 computeDVWorks =
false;
211 if(std::abs(internalEnergy[iNode] - expectedInternalEnergy[iNode]) > 1e-15){
212 computeDVWorks =
false;
215 for(
int iDim = 0;iDim < numDim;iDim++){
216 if(std::abs(velocity[iDim*numNodesDomain+iNode] -
217 expectedVelocity[iDim*numNodesDomain+iNode]) > 1e-15){
218 computeDVWorks =
false;
224 dimComputeDV[numDim-2] = computeDVWorks ;
226 std::cout <<
"Pressure failed" << std::endl;
229 std::cout <<
"Temp failed" << std::endl;
232 std::cout <<
"RhoM1 failed" << std::endl;
235 std::cout <<
"Velo failed" << std::endl;
238 std::cout <<
"Internal energy failed" << std::endl;
244 std::vector<double>
velHat(numDim*numNodesDomain,0.0);
246 std::vector<size_t> fortranBufferInterval(2*numDim,1);
247 for(
int iDim = 0;iDim < numDim;iDim++){
248 fortranBufferInterval[2*iDim+1] = bufferInterval[2*iDim+1] + 1;
252 (&numDim,&numNodes[0],&numNodesDomain,
253 &fortranBufferInterval[0],
254 &gridMetric[0],&velocity[0],&velHat[0]);
256 std::vector<double *> vHatBuffers(numDim,(
double *)NULL);
257 for(
int iDim = 0;iDim < numDim;iDim++){
258 vBuffers[iDim] = &velocity[iDim*numNodesDomain];
259 vHatBuffers[iDim] = &velHat[iDim*numNodesDomain];
265 bool uniformGridMetricWorks =
true;
266 for(
int iDim = 0;iDim < numDim;iDim++){
267 size_t iOffset = iDim*numNodesDomain;
268 for(
int iNode = 0;iNode < numNodesDomain;iNode++){
269 double error = std::abs(velHat[iOffset+iNode] - expectedVHat[iOffset+iNode]);
271 uniformGridMetricWorks =
false;
275 dimUniformGridMetric[numDim-2] = uniformGridMetricWorks;
278 for(
int iDim = 0;iDim < numDim;iDim++){
279 size_t vectorOffset = iDim*numNodesDomain;
280 std::vector<double> scaledPressure(numNodesDomain,0.0);
281 for(
size_t iPoint = 0;iPoint < numNodesDomain;iPoint++)
282 scaledPressure[iPoint] = p[iPoint]*gridMetric[iDim];
283 std::vector<double> eulerFlux(numNodesDomain*(numDim+2),0.0);
284 std::vector<double> expectedFlux((numDim+2)*numNodesDomain,0.0);
285 for(
size_t iPoint = 0;iPoint < numNodesDomain;iPoint++){
287 expectedFlux[iPoint] = rho[iPoint]*velHat[vectorOffset+iPoint];
289 for(
int ivDim = 0;ivDim < numDim;ivDim++){
290 size_t iOffset = ivDim*numNodesDomain;
291 fOffset = iOffset + numNodesDomain;
292 expectedFlux[iPoint+fOffset] =
294 rhoV[iOffset+iPoint]*velHat[vectorOffset+iPoint];
297 expectedFlux[iPoint+fOffset] += scaledPressure[iPoint];
299 fOffset += numNodesDomain;
300 expectedFlux[iPoint+fOffset] =
302 (rhoE[iPoint]+p[iPoint])*velHat[vectorOffset+iPoint];
304 int fluxDim = iDim + 1;
307 (&numDim,&fluxDim,&numNodes[0],&numNodesDomain,&fortranBufferInterval[0],
308 &gridMetric[0],&rho[0],&rhoV[0],&rhoE[0],
309 &velHat[0],&p[0],&scaledPressure[0],&eulerFlux[0]);
311 std::vector<bool> uniformFlux(numDim+2,
true);
312 for(
int fDim = 0 ;fDim < (numDim+2);fDim++){
313 size_t fOffset = fDim * numNodesDomain;
314 bool triggered =
false;
315 for(
size_t iPoint = 0;iPoint < numNodesDomain;iPoint++){
316 if(std::abs(eulerFlux[fOffset+iPoint] - expectedFlux[fOffset+iPoint]) > 1e-15){
318 std::cout <<
"Actual: " << eulerFlux[fOffset+iPoint] << std::endl
319 <<
"Expected: " << expectedFlux[fOffset+iPoint] << std::endl;
322 uniformFlux[fDim] =
false;
326 for(
int fDim = 0;fDim < (numDim+2);fDim++){
327 if(!uniformFlux[fDim]){
328 dimUniformFlux[numDim-2] =
false;
329 std::cout <<
"uniform flux failed in dim,fdim " << iDim
330 <<
"," << fDim << std::endl;
341 for(
int iStencil = 0;iStencil < sbp12.
numStencils;iStencil++)
345 int boundaryDepth = 1;
349 std::vector<int> stencilConnectivity(numDim*numNodesDomain,0);
351 boundaryDepth,&stencilConnectivity[0],
true);
354 std::vector<size_t> applyNodes(numNodesDomain,0);
356 for(
size_t iNode = 0;iNode < numNodesDomain;iNode++)
357 applyNodes[iNode] = nNode++;
364 int *
stencilID = &stencilConnectivity[0];
370 std::vector<double> rhsBuffer((numDim+2)*numNodesDomain,0.0);
373 (&numDim,&numNodes[0],&numNodesDomain,&fortranBufferInterval[0],
374 &fortranBufferInterval[0],&gridMetric[0],
377 &rho[0],&rhoV[0],&rhoE[0],
378 &velHat[0],&p[0],&rhsBuffer[0],&rhsBuffer[numNodesDomain],
379 &rhsBuffer[(numDim+1)*numNodesDomain]);
381 bool eulerRHSWorks =
true;
384 for(
size_t iNode = 0;iNode < numNodesDomain;iNode++){
385 if(std::abs(rhsBuffer[iNode]) > 1e-16){
386 std::cout <<
"drho[" << iNode <<
"] = " << rhsBuffer[iNode] << std::endl;
387 eulerRHSWorks =
false;
389 for(
int iDim = 0;iDim < numDim;iDim++){
390 if(std::abs(rhsBuffer[iNode+(iDim+1)*numNodesDomain]) > 1e-16){
391 std::cout <<
"dV[" << iDim <<
"][" << iNode <<
"] = " 392 << rhsBuffer[iNode+(iDim+1)*numNodesDomain]
394 eulerRHSWorks =
false;
397 if(std::abs(rhsBuffer[iNode+(numDim+1)*numNodesDomain]) > 1e-16){
398 std::cout <<
"dE[" << iNode <<
"] = " 399 << rhsBuffer[iNode+(numDim+1)*numNodesDomain] << std::endl;
400 eulerRHSWorks =
false;
403 dimEulerRHS[numDim-2] = eulerRHSWorks;
406 bool computeDVWorks =
true;
407 bool eulerRHSWorks =
true;
408 bool uniformGridMetricWorks =
true;
409 bool uniformFluxWorks =
true;
411 for(
int nDim = 2;nDim <= 3;nDim++){
412 computeDVWorks = computeDVWorks && dimComputeDV[nDim-2];
413 eulerRHSWorks = eulerRHSWorks && dimEulerRHS[nDim-2];
414 uniformGridMetricWorks = uniformGridMetricWorks && dimUniformGridMetric[nDim-2];
415 uniformFluxWorks = uniformFluxWorks&&dimUniformFlux[nDim-2];
418 serialUnitResults.
UpdateResult(
"Euler:Kernels:DV",computeDVWorks);
419 serialUnitResults.
UpdateResult(
"Euler:Kernels:UniformRHS",eulerRHSWorks);
420 serialUnitResults.
UpdateResult(
"Euler:Kernels:UniformFlux",uniformFluxWorks);
421 serialUnitResults.
UpdateResult(
"Grid:Kernels:ApplyUniformGridMetric",uniformGridMetricWorks);
427 std::cout <<
"TestEulerRHS..." << std::endl;
440 std::ostringstream messageStream;
443 operator_t sbpOperator;
444 halo_t &simHalo(simGrid.
Halo());
448 bool parTestEulerRHS =
true;
453 gridSizes,2,testComm,&messageStream)){
454 parTestEulerRHS =
false;
455 std::cout <<
"TestEulerRHS failed in CreateSimulation Fixtures" << std::endl;
482 parTestEulerRHS =
false;
483 std::cout <<
"TestEulerRHS failed in SetupEulerState" << std::endl;
487 std::cout << messageStream.str() << std::endl;
506 std::vector<double> rho(numPointsBuffer,1.0);
507 std::vector<double> rhoV(3*numPointsBuffer,0.0);
508 std::vector<double> rhoE(3*numPointsBuffer,1.0/(gamma-1.0));
510 std::vector<double> dRho(numPointsBuffer,1.0);
511 std::vector<double> dRhoV(3*numPointsBuffer,0.0);
512 std::vector<double> dRhoE(3*numPointsBuffer,1.0/(gamma-1.0));
514 std::vector<double> T(numPointsBuffer,0.0);
515 std::vector<double> p(numPointsBuffer,0.0);
516 std::vector<double>
V(3*numPointsBuffer,0.0);
518 std::vector<double> rhom1(numPointsBuffer,0.0);
521 simState.SetFieldBuffer(
"simTime",&t);
522 simState.SetFieldBuffer(
"rho",&rho[0]);
523 simState.SetFieldBuffer(
"rhoV",&rhoV[0]);
524 simState.SetFieldBuffer(
"rhoE",&rhoE[0]);
526 simState.SetFieldBuffer(
"pressure",&p[0]);
527 simState.SetFieldBuffer(
"temperature",&T[0]);
528 simState.SetFieldBuffer(
"velocity",&V[0]);
529 simState.SetFieldBuffer(
"rhom1",&rhom1[0]);
531 state_t rhsState(simState);
546 std::cout <<
"Before initialize" << std::endl;
548 if(eulerRHS.Initialize(simGrid,simState,paramState,sbpOperator)){
549 parTestEulerRHS =
false;
550 std::cout <<
"TestEulerRHS failed in eulerRHS.Initialize" << std::endl;
554 std::cout <<
"Done initialize" << std::endl;
556 if(eulerRHS.SetupRHS(simGrid,simState,rhsState)){
557 parTestEulerRHS =
false;
558 std::cout <<
"TestEulerRHS failed in eulerRHS.SetupRHS" << std::endl;
562 std::cout <<
"Done setupRHS" << std::endl;
564 const std::vector<double *> &inputStateBuffers(eulerRHS.StateBuffers());
565 const std::vector<double *> &outputStateBuffers(eulerRHS.RHSBuffers());
569 if(inputStateBuffers[0] != &rho[0])
570 parTestEulerRHS =
false;
571 for(
int iDim = 0;iDim < numDim;iDim++){
572 if(inputStateBuffers[iDim+1] != &rhoV[iDim*numPointsBuffer])
573 parTestEulerRHS =
false;
575 if(inputStateBuffers[numDim+1] != &rhoE[0])
576 parTestEulerRHS =
false;
578 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
579 if(!parTestEulerRHS){
580 std::cout <<
"Problem 1" << std::endl;
583 if(outputStateBuffers[0] != &dRho[0])
584 parTestEulerRHS =
false;
585 if(outputStateBuffers[1] != &dRhoV[0])
586 parTestEulerRHS =
false;
587 if(outputStateBuffers[numDim+1] != &dRhoE[0])
588 parTestEulerRHS =
false;
589 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
590 if(!parTestEulerRHS){
591 std::cout <<
"Problem 2" << std::endl;
594 std::cout <<
"Done Problem 1 and 2" << std::endl;
597 if(eulerRHS.SetupRHS(simGrid,rhsState,simState)){
598 parTestEulerRHS =
false;
600 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
601 if(!parTestEulerRHS){
602 std::cout <<
"Problem 3" << std::endl;
606 if(inputStateBuffers[0] != &dRho[0])
607 parTestEulerRHS =
false;
608 for(
int iDim = 0;iDim < numDim;iDim++)
609 if(inputStateBuffers[iDim+1] != &dRhoV[iDim*numPointsBuffer])
610 parTestEulerRHS =
false;
611 if(inputStateBuffers[numDim+1] != &dRhoE[0])
612 parTestEulerRHS =
false;
613 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
614 if(!parTestEulerRHS){
615 std::cout <<
"Problem 4" << std::endl;
618 std::cout <<
"Done Problem 3 and 4" << std::endl;
621 if(outputStateBuffers[0] != &rho[0])
622 parTestEulerRHS =
false;
623 if(outputStateBuffers[1] != &rhoV[0])
624 parTestEulerRHS =
false;
625 if(outputStateBuffers[numDim+1] != &rhoE[0])
626 parTestEulerRHS =
false;
627 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
628 if(!parTestEulerRHS){
629 std::cout <<
"Problem 5" << std::endl;
632 std::cout <<
"Done Problem 5" << std::endl;
634 int returnCode = eulerRHS.RHS(0);
636 parTestEulerRHS =
false;
639 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
640 if(!parTestEulerRHS){
641 std::cout <<
"Problem 6" <<
" Return code " << returnCode << std::endl;
644 std::cout <<
"Done Problem 6" << std::endl;
646 parallelUnitResults.
UpdateResult(
"Euler:RHS:RunsInParallel",parTestEulerRHS);
652 std::cout <<
"TestEulerRHS2..." << std::endl;
665 std::ostringstream messageStream;
668 operator_t sbpOperator;
669 halo_t &simHalo(simGrid.
Halo());
673 bool parTestEulerRHS =
true;
677 gridSizes,2,testComm,&messageStream)){
678 parTestEulerRHS =
false;
685 parTestEulerRHS =
false;
689 std::cout << messageStream.str() << std::endl;
710 std::vector<double> rho(numPointsBuffer,1.0);
711 std::vector<double> rhoV(3*numPointsBuffer,0.0);
712 std::vector<double> rhoE(3*numPointsBuffer,1.0/(gamma-1.0));
714 std::vector<double> dRho(numPointsBuffer,0.0);
715 std::vector<double> dRhoV(3*numPointsBuffer,0.0);
716 std::vector<double> dRhoE(numPointsBuffer,0.0);
718 std::vector<double> T(numPointsBuffer,0.0);
719 std::vector<double> p(numPointsBuffer,0.0);
720 std::vector<double>
V(3*numPointsBuffer,0.0);
722 std::vector<double> rhom1(numPointsBuffer,0.0);
725 simState.SetFieldBuffer(
"simTime",&t);
726 simState.SetFieldBuffer(
"rho",&rho[0]);
727 simState.SetFieldBuffer(
"rhoV",&rhoV[0]);
728 simState.SetFieldBuffer(
"rhoE",&rhoE[0]);
730 simState.SetFieldBuffer(
"pressure",&p[0]);
731 simState.SetFieldBuffer(
"temperature",&T[0]);
732 simState.SetFieldBuffer(
"velocity",&V[0]);
733 simState.SetFieldBuffer(
"rhom1",&rhom1[0]);
735 state_t rhsState(simState);
750 if(eulerRHS.Initialize(simGrid,simState,paramState,sbpOperator)){
751 parTestEulerRHS =
false;
755 if(eulerRHS.SetupRHS(simGrid,simState,rhsState)){
756 parTestEulerRHS =
false;
761 eulerRHS.InitThreadIntervals();
764 int returnCode = eulerRHS.RHS(0);
766 parTestEulerRHS =
false;
769 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
770 if(!parTestEulerRHS){
771 std::cout <<
"Problem 0" << std::endl;
775 for(
size_t iPoint = 0;(iPoint <
numPointsBuffer)&&parTestEulerRHS;iPoint++){
776 if(std::abs(dRho[iPoint]) > 1e-15) parTestEulerRHS =
false;
777 for(
int iDim = 0;iDim < numDim;iDim++)
778 if(std::abs(dRhoV[iPoint+iDim*numPointsBuffer]) > 1e-15) parTestEulerRHS =
false;
779 if(std::abs(dRhoE[iPoint]) > 1e-15) parTestEulerRHS =
false;
783 parTestEulerRHS =
CheckResult(parTestEulerRHS,testComm);
784 if(!parTestEulerRHS){
785 std::cout <<
"Problem 1" << std::endl;
788 parallelUnitResults.
UpdateResult(
"Euler:RHS:3dWorksInParallel",parTestEulerRHS);
void const size_t const size_t const size_t const int const int const double * gridMetric
int ComputeDVBuffer(const pcpp::IndexIntervalType ®ionInterval, const std::vector< size_t > &bufferSizes, const std::vector< double *> &stateBuffers, std::vector< double *> &dvBuffers)
void size_t int size_t int size_t int int * stencilSizes
subroutine applyuniformgridmetric(numDim, gridSizes, numPoints, opInterval, gridMetric, vBuffer, vHat)
void Flatten(ContainerType &output) const
int * stencilSizes
The number of weights for each stencil.
subroutine uniformrhs(numDim, gridSizes, numPoints, fullInterval, opInterval, gridMetric, numStencils, numStencilValues, stencilSizes, stencilStarts, stencilOffsets, stencilWeights, stencilID, rhoBuffer, rhoVBuffer, rhoEBuffer, velHat, pressureBuffer, rhoRHS, rhoVRHS, rhoERHS)
plascom2::operators::sbp::base operator_t
void SetNumThreads(int numThreads)
void size_t int size_t int size_t int int int * stencilStarts
void const size_t const size_t * gridSizes
bool CheckResult(bool &localResult, pcpp::CommunicatorType &testComm)
void SetupPressureBuffer(double *const inPtr)
int ComputePressureBuffer(const pcpp::IndexIntervalType ®ionInterval, const std::vector< size_t > &bufferSizes)
Compute pressure for the entire buffer.
int * stencilStarts
The starting index into the stencilWeight and stencilOffset arrays for each stencil.
int * stencilOffsets
The offsets wrt the grid point at which the stencil is being applied.
void const size_t const size_t const size_t const int const int const double const double const double const double const double * velHat
pcpp::CommunicatorType comm_t
void SetGamma(const double &inValue)
void SetSpecificGasConstant(const double &inValue)
void const size_t const size_t const size_t const int const double const int const double * velocity
pcpp::IndexIntervalType interval_t
int SetupEulerState(const GridType &inGrid, StateType &inState, StateType &inParams, int numScalars, bool withFluxes=false)
void SetupInternalEnergyBuffer(double *const inPtr)
pcpp::ParallelGlobalType global_t
void TestEulerRHS(ix::test::results ¶llelUnitResults, pcpp::CommunicatorType &testComm)
void SetupTemperatureBuffer(double *const inPtr)
Encapsulating class for collections of test results.
void size_t int size_t int size_t int int int int double int * stencilOffsets
simulation::domain::base< grid_t, state_t > domain_t
void const size_t const size_t const int const size_t const size_t const size_t const size_t const int const double const double const double const double const double const double const double const double const int * numScalar
pcpp::IndexIntervalType & PartitionBufferInterval()
const std::vector< size_t > & GridSizes() const
void size_t int size_t int size_t int int int int double int int * stencilID
void SetupSpecificVolumeBuffer(double *const inPtr)
void SetGridSpacings(const std::vector< double > &inSpacing)
Main encapsulation of MPI.
int InitializeMaterialProperties()
Derive material properties from a minimum required set.
int CreateStencilConnectivity(int numDim, size_t *dimSizes, size_t *opInterval, int boundaryDepth, int *stencilID, bool fortranInterval=false)
Creates simple stencil connectivity assuming all domain boundaries are physical boundaries.
void size_t int size_t int size_t int int int int double int int double double *void size_t int size_t int int int int int double int size_t size_t size_t double double *void size_t int size_t int size_t size_t int double int double double *void size_t size_t size_t double * a
Testing constructs for unit testing.
Encapsulation for a collection of operator stencils.
int numValues
The total number of weights for all stencils (reqd for Fortran)
int CreateSimulationFixtures(GridType &inGrid, HaloType &inHalo, plascom2::operators::sbp::base &inOperator, const std::vector< size_t > &gridSizes, int interiorOrder, pcpp::CommunicatorType &inComm, std::ostream *messageStreamPtr=NULL)
subroutine uniformflux(numDim, fluxDim, gridSizes, numPoints, opInterval, gridMetric, rhoBuffer, rhoVBuffer, rhoEBuffer, velHat, pressureBuffer, scaledPressure, fluxBuffer)
void const size_t const size_t const size_t const int const double * V
void size_t int size_t int size_t int int int int double int int double double *void size_t int size_t int int int int int double int size_t size_t size_t double double *void size_t int size_t int size_t size_t int double int double double *void size_t size_t size_t * bufferInterval
void UpdateResult(const std::string &name, const ValueType &result)
Updates an existing test result.
Perfect Gas Equation of State.
const std::vector< double > & PhysicalExtent() const
double * stencilWeights
The stencil weights.
void size_t int size_t int size_t int int int int double * stencilWeights
void size_t int size_t int size_t int * numStencils
simulation::state::base state_t
int numStencils
The number of stencils (e.g. interior + boundary)
void TestEulerRHS2(ix::test::results ¶llelUnitResults, pcpp::CommunicatorType &testComm)
void const size_t const size_t const size_t const int const double * scalarBuffer
int Initialize(base &stencilSet, int interiorOrder)
Initialize the sbp::base stencilset with the SBP operator of given order.
simulation::grid::halo halo_t
Simple Block Structured Mesh object.
simulation::grid::parallel_blockstructured grid_t
int ComputeTemperatureBuffer(const pcpp::IndexIntervalType ®ionInterval, const std::vector< size_t > &bufferSizes)
Compute temperature for the entire buffer.
void TestEulerKernels(ix::test::results &serialUnitResults)
void SetFieldBuffer(const std::string &name, void *buf)
int Finalize(bool allocateCoordinateData=false)
void InitSimple(const ContainerType &inSize)
size_t BufferSize() const
void const size_t * numPointsBuffer
void FC_MODULE(euler, flux1d, EULER, FLUX1D)(const int *numDim