OilfieldToolsNet/opm-simulators
4
0
Fork 0
mirror of https://github.com/OPM/opm-simulators.git synced 2024-11-29 12:33:49 -06:00
Code Issues Packages Projects Releases Wiki Activity
6b2bf9a100
opm-simulators/tests/referencesolutions/s0004-p0001-co2injection_ncp_ni_ecfv-heuristix.vtu

240 lines
15 KiB
Plaintext
Raw Normal View History

validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
<?xml version="1.0"?>
<VTKFile type="UnstructuredGrid" version="0.1" byte_order="LittleEndian">
<UnstructuredGrid>
<Piece NumberOfCells="96" NumberOfPoints="117">
<CellData Scalars="pressure_l">
<DataArray type="Float32" Name="pressure_l" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
2.63077e+07 2.63082e+07 2.63087e+07 2.6309e+07 2.63093e+07 2.63096e+07 2.63099e+07 2.63103e+07 2.63107e+07 2.63111e+07 2.63116e+07 2.63119e+07
2.62811e+07 2.62817e+07 2.62822e+07 2.62826e+07 2.62829e+07 2.62831e+07 2.62834e+07 2.62838e+07 2.62842e+07 2.62848e+07 2.62854e+07 2.62859e+07
2.62547e+07 2.62554e+07 2.62558e+07 2.62562e+07 2.62564e+07 2.62567e+07 2.6257e+07 2.62574e+07 2.62579e+07 2.62585e+07 2.62594e+07 2.62608e+07
2.62288e+07 2.62293e+07 2.62296e+07 2.62299e+07 2.62301e+07 2.62303e+07 2.62306e+07 2.6231e+07 2.62315e+07 2.62322e+07 2.62333e+07 2.62348e+07
2.6203e+07 2.62032e+07 2.62034e+07 2.62036e+07 2.62038e+07 2.6204e+07 2.62042e+07 2.62046e+07 2.62051e+07 2.62058e+07 2.62068e+07 2.62084e+07
2.61772e+07 2.61772e+07 2.61773e+07 2.61774e+07 2.61775e+07 2.61776e+07 2.61778e+07 2.61781e+07 2.61786e+07 2.61792e+07 2.618e+07 2.61813e+07
2.61514e+07 2.61513e+07 2.61512e+07 2.61511e+07 2.61512e+07 2.61513e+07 2.61514e+07 2.61516e+07 2.6152e+07 2.61524e+07 2.61529e+07 2.61535e+07
2.61257e+07 2.61253e+07 2.6125e+07 2.61249e+07 2.61248e+07 2.61249e+07 2.6125e+07 2.61251e+07 2.61254e+07 2.61257e+07 2.6126e+07 2.61263e+07
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
</DataArray>
<DataArray type="Float32" Name="pressure_g" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
2.63127e+07 2.63132e+07 2.63137e+07 2.6314e+07 2.63143e+07 2.63146e+07 2.63149e+07 2.63153e+07 2.63157e+07 2.63161e+07 2.63166e+07 2.63169e+07
2.62861e+07 2.62867e+07 2.62872e+07 2.62876e+07 2.62879e+07 2.62881e+07 2.62884e+07 2.62888e+07 2.62892e+07 2.62898e+07 2.62904e+07 2.62909e+07
2.62597e+07 2.62604e+07 2.62608e+07 2.62612e+07 2.62614e+07 2.62617e+07 2.6262e+07 2.62624e+07 2.62629e+07 2.62635e+07 2.62644e+07 2.62658e+07
2.62338e+07 2.62343e+07 2.62346e+07 2.62349e+07 2.62351e+07 2.62353e+07 2.62356e+07 2.6236e+07 2.62365e+07 2.62372e+07 2.62383e+07 2.62398e+07
2.6208e+07 2.62082e+07 2.62084e+07 2.62086e+07 2.62088e+07 2.6209e+07 2.62092e+07 2.62096e+07 2.62101e+07 2.62108e+07 2.62118e+07 2.62134e+07
2.61822e+07 2.61822e+07 2.61823e+07 2.61824e+07 2.61825e+07 2.61826e+07 2.61828e+07 2.61831e+07 2.61836e+07 2.61842e+07 2.6185e+07 2.61863e+07
2.61564e+07 2.61563e+07 2.61562e+07 2.61561e+07 2.61562e+07 2.61563e+07 2.61564e+07 2.61566e+07 2.6157e+07 2.61574e+07 2.61579e+07 2.61585e+07
2.61307e+07 2.61303e+07 2.613e+07 2.61299e+07 2.61298e+07 2.61299e+07 2.613e+07 2.61301e+07 2.61304e+07 2.61307e+07 2.6131e+07 2.61313e+07
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
</DataArray>
<DataArray type="Float32" Name="density_l" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
1082.33 1082.33 1082.33 1082.33 1082.33 1082.33 1082.33 1082.33 1082.33 1082.34 1082.34 1082.34
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32 1082.32
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.31 1082.32
1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.3 1082.31
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29 1082.29
1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28 1082.28
1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27 1082.27
1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26 1082.26
</DataArray>
<DataArray type="Float32" Name="density_g" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
969.079 969.081 969.083 969.085 969.086 969.088 969.089 969.09 969.092 969.094 969.096 969.098
968.959 968.962 968.964 968.966 968.967 968.968 968.969 968.971 968.973 968.975 968.978 968.981
968.84 968.843 968.845 968.846 968.848 968.849 968.85 968.852 968.854 968.857 968.861 968.865
968.723 968.725 968.727 968.728 968.729 968.73 968.731 968.733 968.735 968.738 968.743 968.748
968.606 968.608 968.609 968.609 968.61 968.611 968.612 968.614 968.616 968.619 968.624 968.629
968.49 968.491 968.491 968.491 968.492 968.492 968.493 968.495 968.496 968.499 968.503 968.507
968.374 968.373 968.373 968.373 968.373 968.373 968.374 968.375 968.377 968.378 968.381 968.383
968.257 968.256 968.255 968.254 968.254 968.254 968.255 968.256 968.257 968.258 968.259 968.26
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
</DataArray>
<DataArray type="Float32" Name="saturation_l" NumberOfComponents="1" format="ascii">
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
</DataArray>
<DataArray type="Float32" Name="saturation_g" NumberOfComponents="1" format="ascii">
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
</DataArray>
<DataArray type="Float32" Name="relativePerm_l" NumberOfComponents="1" format="ascii">
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1
</DataArray>
<DataArray type="Float32" Name="relativePerm_g" NumberOfComponents="1" format="ascii">
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0
</DataArray>
<DataArray type="Float32" Name="porosity" NumberOfComponents="1" format="ascii">
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3 0.3
</DataArray>
<DataArray type="Float32" Name="temperature" NumberOfComponents="1" format="ascii">
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.151
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.151
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.151
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.151
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15
293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15 293.15
</DataArray>
<DataArray type="Float32" Name="moleFrac_l^Brine" NumberOfComponents="1" format="ascii">
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.994995
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.994995
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.994995
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.994995
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995
0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995 0.995
</DataArray>
<DataArray type="Float32" Name="moleFrac_l^CO2" NumberOfComponents="1" format="ascii">
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.00500542
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.00500542
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.00500542
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.00500542
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005
0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005 0.005
</DataArray>
<DataArray type="Float32" Name="moleFrac_g^Brine" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
0.00327801 0.00327802 0.00327802 0.00327803 0.00327803 0.00327804 0.00327804 0.00327805 0.00327806 0.00327806 0.00327807 0.00327808
0.0032776 0.00327761 0.00327762 0.00327762 0.00327763 0.00327763 0.00327764 0.00327764 0.00327765 0.00327766 0.00327767 0.00327768
0.0032772 0.0032772 0.00327721 0.00327722 0.00327722 0.00327723 0.00327723 0.00327724 0.00327724 0.00327726 0.00327727 0.00327732
0.0032768 0.0032768 0.00327681 0.00327681 0.00327682 0.00327682 0.00327682 0.00327683 0.00327684 0.00327685 0.00327687 0.00327692
0.0032764 0.0032764 0.0032764 0.00327641 0.00327641 0.00327641 0.00327642 0.00327642 0.00327643 0.00327644 0.00327646 0.00327652
0.00327601 0.003276 0.003276 0.003276 0.003276 0.00327601 0.00327601 0.00327602 0.00327602 0.00327603 0.00327605 0.0032761
0.00327561 0.0032756 0.0032756 0.0032756 0.0032756 0.0032756 0.0032756 0.00327561 0.00327561 0.00327562 0.00327563 0.00327564
0.00327522 0.0032752 0.00327519 0.00327519 0.00327519 0.00327519 0.00327519 0.0032752 0.0032752 0.00327521 0.00327521 0.00327521
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
</DataArray>
<DataArray type="Float32" Name="moleFrac_g^CO2" NumberOfComponents="1" format="ascii">
parallelization: treat off-diagonal matrix entries on the process boundaries properly this is required so that the element-centered finite volume method does not handle each partition of the domain separately. (i.e. so that fluxes accross faces on the process boundaries are considered) mea culpa! The fix for this is to also include these entries in the matrix which uses domestic indices. This required some rather extensive changes to the blacklisting mechanism as for this it must be possible to translate the index of a blacklisted entity (i.e., an entity in a ghost or an overlap cell) to a domestic index (i.e., the corresponding index in the algebraic overlap). Note that the code for algebraic overlaps is *fun* and the person who wrote it should be tarred and feathered. (*ouch* ;)) Seriously: Better approaches than "lets-throw-this-away-and-use-grid-overlaps" are deeply appreciated. (The grid overlap is not really useful in Dune because only "Mickey Mouse grids" like Dune::YaspGrid support it.)
2014-07-20 08:46:03 -05:00
0.259415 0.259414 0.259414 0.259414 0.259413 0.259413 0.259413 0.259413 0.259413 0.259412 0.259412 0.259412
0.259434 0.259434 0.259433 0.259433 0.259433 0.259433 0.259432 0.259432 0.259432 0.259431 0.259431 0.259431
0.259453 0.259453 0.259452 0.259452 0.259452 0.259452 0.259451 0.259451 0.259451 0.25945 0.25945 0.259731
0.259472 0.259472 0.259471 0.259471 0.259471 0.259471 0.259471 0.25947 0.25947 0.259469 0.259469 0.25975
0.259491 0.25949 0.25949 0.25949 0.25949 0.25949 0.25949 0.259489 0.259489 0.259488 0.259488 0.259769
0.259509 0.259509 0.259509 0.259509 0.259509 0.259509 0.259508 0.259508 0.259508 0.259508 0.259507 0.259788
0.259528 0.259527 0.259528 0.259528 0.259528 0.259527 0.259527 0.259527 0.259527 0.259527 0.259526 0.259526
0.259546 0.259546 0.259546 0.259546 0.259546 0.259546 0.259546 0.259546 0.259546 0.259546 0.259545 0.259545
validate the results produced by the parallel tests this implied a few changes to the "runtest.sh" script and requires reference solutions...
2014-03-06 07:37:32 -06:00
</DataArray>
</CellData>
<Points>
<DataArray type="Float32" Name="Coordinates" NumberOfComponents="3" format="ascii">
30 0 0 32.5 0 0 30 2.5 0 32.5 2.5 0
35 0 0 35 2.5 0 37.5 0 0 37.5 2.5 0
40 0 0 40 2.5 0 42.5 0 0 42.5 2.5 0
45 0 0 45 2.5 0 47.5 0 0 47.5 2.5 0
50 0 0 50 2.5 0 52.5 0 0 52.5 2.5 0
55 0 0 55 2.5 0 57.5 0 0 57.5 2.5 0
60 0 0 60 2.5 0 30 5 0 32.5 5 0
35 5 0 37.5 5 0 40 5 0 42.5 5 0
45 5 0 47.5 5 0 50 5 0 52.5 5 0
55 5 0 57.5 5 0 60 5 0 30 7.5 0
32.5 7.5 0 35 7.5 0 37.5 7.5 0 40 7.5 0
42.5 7.5 0 45 7.5 0 47.5 7.5 0 50 7.5 0
52.5 7.5 0 55 7.5 0 57.5 7.5 0 60 7.5 0
30 10 0 32.5 10 0 35 10 0 37.5 10 0
40 10 0 42.5 10 0 45 10 0 47.5 10 0
50 10 0 52.5 10 0 55 10 0 57.5 10 0
60 10 0 30 12.5 0 32.5 12.5 0 35 12.5 0
37.5 12.5 0 40 12.5 0 42.5 12.5 0 45 12.5 0
47.5 12.5 0 50 12.5 0 52.5 12.5 0 55 12.5 0
57.5 12.5 0 60 12.5 0 30 15 0 32.5 15 0
35 15 0 37.5 15 0 40 15 0 42.5 15 0
45 15 0 47.5 15 0 50 15 0 52.5 15 0
55 15 0 57.5 15 0 60 15 0 30 17.5 0
32.5 17.5 0 35 17.5 0 37.5 17.5 0 40 17.5 0
42.5 17.5 0 45 17.5 0 47.5 17.5 0 50 17.5 0
52.5 17.5 0 55 17.5 0 57.5 17.5 0 60 17.5 0
30 20 0 32.5 20 0 35 20 0 37.5 20 0
40 20 0 42.5 20 0 45 20 0 47.5 20 0
50 20 0 52.5 20 0 55 20 0 57.5 20 0
60 20 0
</DataArray>
</Points>
<Cells>
<DataArray type="Int32" Name="connectivity" NumberOfComponents="1" format="ascii">
0 1 3 2 1 4 5 3 4 6 7 5
6 8 9 7 8 10 11 9 10 12 13 11
12 14 15 13 14 16 17 15 16 18 19 17
18 20 21 19 20 22 23 21 22 24 25 23
2 3 27 26 3 5 28 27 5 7 29 28
7 9 30 29 9 11 31 30 11 13 32 31
13 15 33 32 15 17 34 33 17 19 35 34
19 21 36 35 21 23 37 36 23 25 38 37
26 27 40 39 27 28 41 40 28 29 42 41
29 30 43 42 30 31 44 43 31 32 45 44
32 33 46 45 33 34 47 46 34 35 48 47
35 36 49 48 36 37 50 49 37 38 51 50
39 40 53 52 40 41 54 53 41 42 55 54
42 43 56 55 43 44 57 56 44 45 58 57
45 46 59 58 46 47 60 59 47 48 61 60
48 49 62 61 49 50 63 62 50 51 64 63
52 53 66 65 53 54 67 66 54 55 68 67
55 56 69 68 56 57 70 69 57 58 71 70
58 59 72 71 59 60 73 72 60 61 74 73
61 62 75 74 62 63 76 75 63 64 77 76
65 66 79 78 66 67 80 79 67 68 81 80
68 69 82 81 69 70 83 82 70 71 84 83
71 72 85 84 72 73 86 85 73 74 87 86
74 75 88 87 75 76 89 88 76 77 90 89
78 79 92 91 79 80 93 92 80 81 94 93
81 82 95 94 82 83 96 95 83 84 97 96
84 85 98 97 85 86 99 98 86 87 100 99
87 88 101 100 88 89 102 101 89 90 103 102
91 92 105 104 92 93 106 105 93 94 107 106
94 95 108 107 95 96 109 108 96 97 110 109
97 98 111 110 98 99 112 111 99 100 113 112
100 101 114 113 101 102 115 114 102 103 116 115
</DataArray>
<DataArray type="Int32" Name="offsets" NumberOfComponents="1" format="ascii">
4 8 12 16 20 24 28 32 36 40 44 48
52 56 60 64 68 72 76 80 84 88 92 96
100 104 108 112 116 120 124 128 132 136 140 144
148 152 156 160 164 168 172 176 180 184 188 192
196 200 204 208 212 216 220 224 228 232 236 240
244 248 252 256 260 264 268 272 276 280 284 288
292 296 300 304 308 312 316 320 324 328 332 336
340 344 348 352 356 360 364 368 372 376 380 384
</DataArray>
<DataArray type="UInt8" Name="types" NumberOfComponents="1" format="ascii">
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
9 9 9 9 9 9 9 9 9 9 9 9
</DataArray>
</Cells>
</Piece>
</UnstructuredGrid>
</VTKFile>
Reference in New Issue Copy Permalink