zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

STYLE: Fixing code style requirements for more files - those not

Browse Source 
picked up by a copyright change.
This commit is contained in:
graham
2010-07-29 11:28:44 +01:00
parent f26b8c1cc7
commit 28345247a7
78 changed files with 13805 additions and 13566 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
applications/solvers/combustion/coldEngineFoam/logSummary.H
View File

@ -1,6 +1,8 @@
Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl; Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean u':" << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() << endl; Info<< "Mean u':"
<< (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value()
<< endl;
logSummaryFile logSummaryFile
<< runTime.theta() << tab << runTime.theta() << tab

4
applications/solvers/combustion/dieselEngineFoam/logSummary.H
View File

@ -1,6 +1,8 @@
Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl; Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean u':" << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() << endl; Info<< "Mean u':"
<< (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value()
<< endl;
logSummaryFile logSummaryFile
<< runTime.theta() << tab << runTime.theta() << tab

4
applications/solvers/combustion/engineFoam/logSummary.H
View File

@ -1,6 +1,8 @@
Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl; Info<< "Mean pressure:" << p.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl; Info<< "Mean temperature:" << T.weightedAverage(mesh.V()).value() << endl;
Info<< "Mean u':" << (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value() << endl; Info<< "Mean u':"
<< (sqrt((2.0/3.0)*turbulence->k()))().weightedAverage(mesh.V()).value()
<< endl;
logSummaryFile logSummaryFile
<< runTime.theta() << tab << runTime.theta() << tab

11
applications/solvers/compressible/rhopSonicFoam/resetPhiPatches.H
View File

@ -1,6 +1,11 @@
surfaceScalarField::GeometricBoundaryField& phiPatches = phi.boundaryField(); surfaceScalarField::GeometricBoundaryField& phiPatches =
const volVectorField::GeometricBoundaryField& rhoUpatches = rhoU.boundaryField(); phi.boundaryField();
const surfaceVectorField::GeometricBoundaryField& SfPatches = mesh.Sf().boundaryField();
const volVectorField::GeometricBoundaryField& rhoUpatches =
rhoU.boundaryField();
const surfaceVectorField::GeometricBoundaryField& SfPatches =
mesh.Sf().boundaryField();
forAll(phiPatches, patchI) forAll(phiPatches, patchI)
{ {

6
applications/solvers/heatTransfer/chtMultiRegionFoam/include/setMultiRegionDeltaT.H
View File

@ -25,9 +25,9 @@ Global
setMultiRegionDeltaT setMultiRegionDeltaT
Description Description
Reset the timestep to maintain a constant maximum courant and diffusion Reset the timestep to maintain a constant maximum courant and
Numbers. Reduction of time-step is immediate, but increase is damped to avoid diffusion Numbers. Reduction of time-step is immediate, but
unstable oscillations. increase is damped to avoid unstable oscillations.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/

8
applications/solvers/incompressible/adjointShapeOptimizationFoam/createFields.H
View File

@ -67,7 +67,13 @@
label paRefCell = 0; label paRefCell = 0;
scalar paRefValue = 0.0; scalar paRefValue = 0.0;
setRefCell(pa, mesh.solutionDict().subDict("SIMPLE"), paRefCell, paRefValue); setRefCell
(
pa,
mesh.solutionDict().subDict("SIMPLE"),
paRefCell,
paRefValue
);
singlePhaseTransportModel laminarTransport(U, phi); singlePhaseTransportModel laminarTransport(U, phi);

4
applications/solvers/incompressible/boundaryFoam/interrogateWallPatches.H
View File

@ -59,7 +59,8 @@ if (nWallFaces == 0)
} }
else else
{ {
Info<< "Generating wall data for patch: " << patches[patchId].name() << endl; Info<< "Generating wall data for patch: " << patches[patchId].name()
<< endl;
} }
// store local id of near-walll cell to process // store local id of near-walll cell to process
@ -71,4 +72,3 @@ scalarField y =
& (mesh.C().internalField() - mesh.C().boundaryField()[patchId][faceId]); & (mesh.C().internalField() - mesh.C().boundaryField()[patchId][faceId]);
Info<< " Height to first cell centre y0 = " << y[cellId] << endl; Info<< " Height to first cell centre y0 = " << y[cellId] << endl;

8
applications/solvers/multiphase/bubbleFoam/alphaEqn.H
View File

@ -34,7 +34,13 @@
betaEqn.relax(); betaEqn.relax();
betaEqn.solve(); betaEqn.solve();
alpha = 0.5*(scalar(1) + sqr(scalar(1) - beta) - sqr(scalar(1) - alpha)); alpha =
0.5
*(
scalar(1)
+ sqr(scalar(1) - beta)
- sqr(scalar(1) - alpha)
);
*/ */
beta = scalar(1) - alpha; beta = scalar(1) - alpha;

6
applications/solvers/multiphase/bubbleFoam/pEqn.H
View File

@ -32,7 +32,11 @@
phi = alphaf*phia + betaf*phib; phi = alphaf*phia + betaf*phib;
surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob); surfaceScalarField Dp
(
"(rho*(1|A(U)))",
alphaf*rUaAf/rhoa + betaf*rUbAf/rhob
);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{ {

11
applications/solvers/multiphase/cavitatingFoam/resetPhivPatches.H
View File

@ -1,6 +1,11 @@
surfaceScalarField::GeometricBoundaryField& phivPatches = phiv.boundaryField(); surfaceScalarField::GeometricBoundaryField& phivPatches =
const volVectorField::GeometricBoundaryField& Upatches = U.boundaryField(); phiv.boundaryField();
const surfaceVectorField::GeometricBoundaryField& SfPatches = mesh.Sf().boundaryField();
const volVectorField::GeometricBoundaryField& Upatches =
U.boundaryField();
const surfaceVectorField::GeometricBoundaryField& SfPatches =
mesh.Sf().boundaryField();
forAll(phivPatches, patchI) forAll(phivPatches, patchI)
{ {

3
applications/solvers/multiphase/compressibleInterDyMFoam/pEqn.H
View File

@ -26,7 +26,8 @@
phi = phiU + phi = phiU +
( (
fvc::interpolate(interface.sigmaK())*fvc::snGrad(alpha1)*mesh.magSf() fvc::interpolate(interface.sigmaK())
*fvc::snGrad(alpha1)*mesh.magSf()
+ fvc::interpolate(rho)*(g & mesh.Sf()) + fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf; )*rUAf;

12
applications/solvers/multiphase/compressibleInterFoam/alphaEqns.H
View File

@ -59,7 +59,17 @@
alpharScheme alpharScheme
); );
MULES::explicitSolve(geometricOneField(), alpha1, phi, phiAlpha1, Sp, Su, 1, 0); MULES::explicitSolve
(
geometricOneField(),
alpha1,
phi,
phiAlpha1,
Sp,
Su,
1,
0
);
surfaceScalarField rho1f = fvc::interpolate(rho1); surfaceScalarField rho1f = fvc::interpolate(rho1);
surfaceScalarField rho2f = fvc::interpolate(rho2); surfaceScalarField rho2f = fvc::interpolate(rho2);

3
applications/solvers/multiphase/compressibleInterFoam/pEqn.H
View File

@ -26,7 +26,8 @@
phi = phiU + phi = phiU +
( (
fvc::interpolate(interface.sigmaK())*fvc::snGrad(alpha1)*mesh.magSf() fvc::interpolate(interface.sigmaK())
*fvc::snGrad(alpha1)*mesh.magSf()
+ fvc::interpolate(rho)*(g & mesh.Sf()) + fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf; )*rUAf;

3
applications/solvers/multiphase/interFoam/pEqn.H
View File

@ -15,7 +15,8 @@
phi = phiU + phi = phiU +
( (
fvc::interpolate(interface.sigmaK())*fvc::snGrad(alpha1)*mesh.magSf() fvc::interpolate(interface.sigmaK())
*fvc::snGrad(alpha1)*mesh.magSf()
+ fvc::interpolate(rho)*(g & mesh.Sf()) + fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf; )*rUAf;

26
applications/solvers/multiphase/interPhaseChangeFoam/alphaEqn.H
View File

@ -50,9 +50,29 @@
+ vDotcAlphal + vDotcAlphal
); );
//MULES::explicitSolve(alpha1, phi, phiAlpha, 1, 0); // MULES::explicitSolve(alpha1, phi, phiAlpha, 1, 0);
//MULES::explicitSolve(geometricOneField(), alpha1, phi, phiAlpha, Sp, Su, 1, 0); // MULES::explicitSolve
MULES::implicitSolve(geometricOneField(), alpha1, phi, phiAlpha, Sp, Su, 1, 0); // (
// geometricOneField(),
// alpha1,
// phi,
// phiAlpha,
// Sp,
// Su,
// 1,
// 0
// );
MULES::implicitSolve
(
geometricOneField(),
alpha1,
phi,
phiAlpha,
Sp,
Su,
1,
0
);
rhoPhi += rhoPhi +=
(runTime.deltaT()/totalDeltaT) (runTime.deltaT()/totalDeltaT)

3
applications/solvers/multiphase/interPhaseChangeFoam/pEqn.H
View File

@ -15,7 +15,8 @@
phi = phiU + phi = phiU +
( (
fvc::interpolate(interface.sigmaK())*fvc::snGrad(alpha1)*mesh.magSf() fvc::interpolate(interface.sigmaK())
*fvc::snGrad(alpha1)*mesh.magSf()
+ fvc::interpolate(rho)*(g & mesh.Sf()) + fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf; )*rUAf;

6
applications/solvers/multiphase/twoPhaseEulerFoam/pEqn.H
View File

@ -45,7 +45,11 @@
phi = alphaf*phia + betaf*phib; phi = alphaf*phia + betaf*phib;
surfaceScalarField Dp("(rho*(1|A(U)))", alphaf*rUaAf/rhoa + betaf*rUbAf/rhob); surfaceScalarField Dp
(
"(rho*(1|A(U)))",
alphaf*rUaAf/rhoa + betaf*rUbAf/rhob
);
for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++) for (int nonOrth=0; nonOrth<=nNonOrthCorr; nonOrth++)
{ {

182
applications/test/HashingSpeed/testHashingSpeed.C
View File

@ -705,17 +705,22 @@ static uint32_t crc_16_table[16] = {
}; };
/* /*
* This code was found at: http://wannabe.guru.org/alg/node191.html * This code was found at: http://wannabe.guru.org/alg/node191.html
* and still exists here: http://www.fearme.com/misc/alg/node191.html * and still exists here: http://www.fearme.com/misc/alg/node191.html
* *
* this source code is based on Rex and Binstock which, in turn, * this source code is based on Rex and Binstock which, in turn,
* acknowledges William James Hunt. * acknowledges William James Hunt.
* *
* According to the site this CRC uses the polynomial x^16+x^5+x^2+1. * According to the site this CRC uses the polynomial x^16+x^5+x^2+1.
* Unfortunately, DOCSIS uses x^16+x^12+x^5+1. D'oh! * Unfortunately, DOCSIS uses x^16+x^12+x^5+1. D'oh!
*/ */
static uint32_t GetCRC16Update (uint32_t start_crc, const char * data_stream, int length) { static uint32_t GetCRC16Update
(
uint32_t start_crc,
const char * data_stream,
int length
) {
uint32_t crc = start_crc; uint32_t crc = start_crc;
uint32_t r; uint32_t r;
@ -740,7 +745,7 @@ uint32_t r;
} }
uint32_t GetCRC16 (const char * data_stream, int length) { uint32_t GetCRC16 (const char * data_stream, int length) {
return GetCRC16Update (0, data_stream, length); return GetCRC16Update (0, data_stream, length);
} }
/* ======================================================================== */ /* ======================================================================== */
@ -794,35 +799,40 @@ static void GenerateCRC32Table (void) {
register int i, j; register int i, j;
register uint32_t crc_accum; register uint32_t crc_accum;
for ( i = 0; i < 256; i++ ) { for ( i = 0; i < 256; i++ ) {
crc_accum = ( (unsigned long) i << 24 ); crc_accum = ( (unsigned long) i << 24 );
for ( j = 0; j < 8; j++ ) { for ( j = 0; j < 8; j++ ) {
if ( crc_accum & 0x80000000L ) { if ( crc_accum & 0x80000000L ) {
crc_accum = ( crc_accum << 1 ) ^ CRC32POLYNOMIAL; crc_accum = ( crc_accum << 1 ) ^ CRC32POLYNOMIAL;
} else { } else {
crc_accum = ( crc_accum << 1 ); crc_accum = ( crc_accum << 1 );
} }
} }
crc_table[i] = crc_accum; crc_table[i] = crc_accum;
} }
return; return;
} }
/* update the CRC on the data block one byte at a time */ /* update the CRC on the data block one byte at a time */
static uint32_t UpdateCRC32 (uint32_t crc_accum, const char *data_blk_ptr, int data_blk_size) { static uint32_t UpdateCRC32
(
uint32_t crc_accum,
const char *data_blk_ptr,
int data_blk_size
) {
register int j; register int j;
register uint8_t i; register uint8_t i;
for (j = 0; j < data_blk_size; j++) { for (j = 0; j < data_blk_size; j++) {
i = (crc_accum >> 24) ^ *data_blk_ptr++; i = (crc_accum >> 24) ^ *data_blk_ptr++;
crc_accum = (crc_accum << 8) ^ crc_table[i]; crc_accum = (crc_accum << 8) ^ crc_table[i];
} }
return crc_accum; return crc_accum;
} }
uint32_t GetCRC32 (const char * data_stream, int length) { uint32_t GetCRC32 (const char * data_stream, int length) {
return UpdateCRC32 (0, data_stream, length); return UpdateCRC32 (0, data_stream, length);
} }
/* ======================================================================== */ /* ======================================================================== */
@ -835,14 +845,14 @@ int j;
uint8_t i0, i1; uint8_t i0, i1;
uint32_t crc_accum0 = 0, crc_accum1 = 0x23456789u; uint32_t crc_accum0 = 0, crc_accum1 = 0x23456789u;
if (data_blk_size & 1) crc_accum0 ^= *data_blk_ptr++; if (data_blk_size & 1) crc_accum0 ^= *data_blk_ptr++;
for (j = 1; j < data_blk_size; j+=2) { for (j = 1; j < data_blk_size; j+=2) {
i0 = ((crc_accum0 >> 24) ^ *data_blk_ptr++); i0 = ((crc_accum0 >> 24) ^ *data_blk_ptr++);
i1 = ((crc_accum1 >> 24) ^ *data_blk_ptr++); i1 = ((crc_accum1 >> 24) ^ *data_blk_ptr++);
crc_accum0 = (crc_accum0 << 8) ^ crc_table[i0]; crc_accum0 = (crc_accum0 << 8) ^ crc_table[i0];
crc_accum1 = (crc_accum1 << 8) ^ crc_table[i1]; crc_accum1 = (crc_accum1 << 8) ^ crc_table[i1];
} }
return crc_accum0 + crc_accum1; return crc_accum0 + crc_accum1;
} }
/* ======================================================================== */ /* ======================================================================== */
@ -855,11 +865,11 @@ uint32_t FNVHash (const char * data, int len) {
int i; int i;
uint32_t hash; uint32_t hash;
hash = 2166136261u; hash = 2166136261u;
for (i=0; i < len; i++) { for (i=0; i < len; i++) {
hash = (16777619u * hash) ^ data[i]; hash = (16777619u * hash) ^ data[i];
} }
return hash; return hash;
} }
/* ======================================================================== */ /* ======================================================================== */
@ -872,15 +882,15 @@ uint32_t oneAtATimeHash (const char * s, int len) {
int32_t hash; int32_t hash;
int i; int i;
for (hash = 0, i = 0; i < len; i++) { for (hash = 0, i = 0; i < len; i++) {
hash += s[i]; hash += s[i];
hash += (hash << 10); hash += (hash << 10);
hash ^= (hash >> 6); /* Non-portable due to ANSI C */ hash ^= (hash >> 6); /* Non-portable due to ANSI C */
} }
hash += (hash << 3); hash += (hash << 3);
hash ^= (hash >> 11); /* Non-portable due to ANSI C */ hash ^= (hash >> 11); /* Non-portable due to ANSI C */
hash += (hash << 15); hash += (hash << 15);
return (uint32_t) hash; return (uint32_t) hash;
} }
/* ======================================================================== */ /* ======================================================================== */
@ -889,23 +899,23 @@ uint32_t oneAtATimeHashPH (const char * s, int len) {
int32_t hash0 = 0, hash1 = 0x23456789; int32_t hash0 = 0, hash1 = 0x23456789;
int i; int i;
if (len & 1) hash1 ^= *s++; if (len & 1) hash1 ^= *s++;
for (i = 1; i < len; i+=2) { for (i = 1; i < len; i+=2) {
hash0 += *s++; hash0 += *s++;
hash1 += *s++; hash1 += *s++;
hash0 += (hash0 << 10); hash0 += (hash0 << 10);
hash1 += (hash1 << 10); hash1 += (hash1 << 10);
hash0 ^= (hash0 >> 6); /* Non-portable due to ANSI C */ hash0 ^= (hash0 >> 6); /* Non-portable due to ANSI C */
hash1 ^= (hash1 >> 6); /* Non-portable due to ANSI C */ hash1 ^= (hash1 >> 6); /* Non-portable due to ANSI C */
} }
hash0 += hash1; hash0 += hash1;
hash0 += (hash0 << 3); hash0 += (hash0 << 3);
hash0 ^= (hash0 >> 11); /* Non-portable due to ANSI C */ hash0 ^= (hash0 >> 11); /* Non-portable due to ANSI C */
hash0 += (hash0 << 15); hash0 += (hash0 << 15);
return (uint32_t) hash0; return (uint32_t) hash0;
} }
/* ======================================================================== */ /* ======================================================================== */
@ -1029,42 +1039,42 @@ static char buff[BUFF_SZ];
clock_t c0, c1; clock_t c0, c1;
int32_t i; int32_t i;
for (buff[0]=0, i=1; i < BUFF_SZ; i++) buff[i] = (char) (i + buff[i-1]); for (buff[0]=0, i=1; i < BUFF_SZ; i++) buff[i] = (char) (i + buff[i-1]);
c0 = clock (); c0 = clock ();
for (i=0; i < NTESTS; i++) hash (buff, BUFF_SZ); for (i=0; i < NTESTS; i++) hash (buff, BUFF_SZ);
c1 = clock (); c1 = clock ();
return (c1 - c0)*(1.0 / (double)CLOCKS_PER_SEC); return (c1 - c0)*(1.0 / (double)CLOCKS_PER_SEC);
} }
struct tagtest { struct tagtest {
double res; double res;
char * name; char * name;
hashFn hash; hashFn hash;
} tests[] = { } tests[] = {
// { 0.0, "CRC32\t\t", GetCRC32 }, // { 0.0, "CRC32\t\t", GetCRC32 },
// { 0.0, "oneAtATimeHash\t", oneAtATimeHash }, // { 0.0, "oneAtATimeHash\t", oneAtATimeHash },
// { 0.0, "alphaNumHash\t", alphaNumHash }, // { 0.0, "alphaNumHash\t", alphaNumHash },
{ 0.0, "FNVHash\t\t", FNVHash }, { 0.0, "FNVHash\t\t", FNVHash },
{ 0.0, "bernstein\t", bernstein }, { 0.0, "bernstein\t", bernstein },
{ 0.0, "stroustrup\t", stroustrup }, { 0.0, "stroustrup\t", stroustrup },
{ 0.0, "hashLookup3\t", hashLookup3 }, { 0.0, "hashLookup3\t", hashLookup3 },
{ 0.0, "hashLookup3Orig\t", hashLookup3Orig }, { 0.0, "hashLookup3Orig\t", hashLookup3Orig },
{ 0.0, "SuperFastHash\t", SuperFastHash }, { 0.0, "SuperFastHash\t", SuperFastHash },
{ 0.0, NULL, NULL } { 0.0, NULL, NULL }
}; };
int main () { int main () {
int i, j; int i, j;
GenerateCRC32Table (); GenerateCRC32Table ();
for (j=0; tests[j].name != NULL; j++) { for (j=0; tests[j].name != NULL; j++) {
for (i=0; i < 3; i++) { for (i=0; i < 3; i++) {
double res = test (tests[j].hash); double res = test (tests[j].hash);
if (tests[j].res == 0.0 || tests[j].res > res) tests[j].res = res; if (tests[j].res == 0.0 || tests[j].res > res) tests[j].res = res;
} }
printf ("%s:%8.4fs\n", tests[j].name, tests[j].res); printf ("%s:%8.4fs\n", tests[j].name, tests[j].res);
} }
return 0; return 0;
} }

9
applications/test/PackedList/PackedListTest.C
View File

@ -53,12 +53,15 @@ inline void reportInfo()
<< " utilization: " << (nBits * offset) << nl; << " utilization: " << (nBits * offset) << nl;
Info<< " Masking:" << nl Info<< " Masking:" << nl
<< " shift << " << unsigned(nBits * offset) << nl << " shift << "
<< " shift >> " << unsigned((sizeof(unsigned)*CHAR_BIT) - nBits * offset) << unsigned(nBits * offset) << nl
<< " shift >> "
<< unsigned((sizeof(unsigned)*CHAR_BIT) - nBits * offset)
<< nl; << nl;
hex(Info); hex(Info);
Info<< " maskLower: " << PackedList<nBits>::maskLower(PackedList<nBits>::packing()) Info<< " maskLower: "
<< PackedList<nBits>::maskLower(PackedList<nBits>::packing())
<< nl << nl
<< " useSHL: " << useSHL << nl << " useSHL: " << useSHL << nl
<< " useSHR: " << useSHR << nl; << " useSHR: " << useSHR << nl;

6
applications/test/dictionary/dictionaryTest.C
View File

@ -62,11 +62,13 @@ int main(int argc, char *argv[])
dictionary dict2(dict1.xfer()); dictionary dict2(dict1.xfer());
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << nl
<< "dict2.toc(): " << dict2.name() << " " << dict2.toc() << endl; << "dict2.toc(): " << dict2.name() << " " << dict2.toc()
<< endl;
// copy back // copy back
dict1 = dict2; dict1 = dict2;
Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc() << endl; Info<< "dict1.toc(): " << dict1.name() << " " << dict1.toc()
<< endl;
dictionary dict3(dict2.subDictPtr("boundaryField")); dictionary dict3(dict2.subDictPtr("boundaryField"));
dictionary dict4(dict2.subDictPtr("NONEXISTENT")); dictionary dict4(dict2.subDictPtr("NONEXISTENT"));

7
applications/test/quaternion/quaternionTest.C
View File

@ -29,8 +29,11 @@ int main()
Info<< "tr.transform(v) " << tr.transform(v) << endl; Info<< "tr.transform(v) " << tr.transform(v) << endl;
Info<< "(septernion(vector(0, -1, 0))*q*septernion(vector(0, 1, 0))).transform(v) " Info<< "(septernion(vector(0, -1, 0))*q*septernion(vector(0, 1, 0)))"
<< (septernion(vector(0, -1, 0))*q*septernion(vector(0, 1, 0))).transform(v) << ".transform(v) "
<< (septernion(vector(0, -1, 0))
*q
*septernion(vector(0, 1, 0))).transform(v)
<< endl; << endl;
return 0; return 0;

2
applications/test/readCHEMKINIII/CHEMKINdata/chem.inp_france
View File

@ -326,7 +326,7 @@ CH3+CH3(+M)=C2H6(+M) 3.6E13 0. 0. !(14,-14)<BAULCH94>
!-------------------------------------------------------------------------------------! !-------------------------------------------------------------------------------------!
!fittings (20/12/94, F. Battin-Leclerc) on CH4-02 system in PSR between 500 and 1300C! !fittings (20/12/94, F. Battin-Leclerc) on CH4-02 system in PSR between 500 and 1300C!
!CH3+CH3(+M)=C2H6(+M) 1.5E14 0. 0.! !(14,-14)<BAULCH94*4>! !CH3+CH3(+M)=C2H6(+M) 1.5E14 0. 0.! !(14,-14)<BAULCH94*4>!
! LOW /5.2E41 -7. 3.0E3/! ! LOW /5.2E41 -7. 3.0E3/!
!-------------------------------------------------------------------------------------! !-------------------------------------------------------------------------------------!
TROE /0.62 73. 1180./ TROE /0.62 73. 1180./
CH3+CH3=C2H5+H 3.0E13 0. 13.5E3 !(15,-15)<BAULCH94> CH3+CH3=C2H5+H 3.0E13 0. 13.5E3 !(15,-15)<BAULCH94>

3
applications/utilities/parallelProcessing/reconstructParMesh/reconstructParMesh.C
View File

@ -452,7 +452,8 @@ int main(int argc, char *argv[])
<< "(there is a points file in " << pointsInstance << "(there is a points file in " << pointsInstance
<< ")" << endl << ")" << endl
<< "Please rerun with the correct time specified" << "Please rerun with the correct time specified"
<< " (through the -constant, -time or -latestTime (at your option)." << " (through the -constant, -time or -latestTime "
<< "(at your option)."
<< endl << exit(FatalError); << endl << exit(FatalError);
} }

5
applications/utilities/postProcessing/dataConversion/foamToTecplot360/foamToTecplot360.C
View File

@ -1272,7 +1272,10 @@ int main(int argc, char *argv[])
//Info<< " symm tensors :"; //Info<< " symm tensors :";
//print(Info, symmNames); //print(Info, symmNames);
// //
//wordList tensorNames(sprayObjs.names(tensorIOField::typeName)); //wordList tensorNames
//(
// sprayObjs.names(tensorIOField::typeName)
//);
//Info<< " tensors :"; //Info<< " tensors :";
//print(Info, tensorNames); //print(Info, tensorNames);

5
applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
View File

@ -112,7 +112,10 @@ Note
@verbatim @verbatim
<?xml version="1.0"?> <?xml version="1.0"?>
<VTKFile type="Collection" version="0.1" byte_order="LittleEndian" compressor="vtkZLibDataCompressor"> <VTKFile type="Collection"
version="0.1"
byte_order="LittleEndian"
compressor="vtkZLibDataCompressor">
<Collection> <Collection>
<DataSet timestep="50" file="pitzDaily_2.vtu"/> <DataSet timestep="50" file="pitzDaily_2.vtu"/>
<DataSet timestep="100" file="pitzDaily_3.vtu"/> <DataSet timestep="100" file="pitzDaily_3.vtu"/>

3
applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_maxsize_info.H
View File

@ -19,7 +19,8 @@ int USERD_get_maxsize_info
label nPyr05Max = 0; label nPyr05Max = 0;
label nTet04Max = 0; label nTet04Max = 0;
Info<< "Checking all time steps for EnSight memory allocation purpose. This can take some time." << endl; Info<< "Checking all time steps for EnSight memory allocation purpose. "
<< "This can take some time." << endl;
for (label timeI=1; timeI < timeDirs.size(); ++timeI) for (label timeI=1; timeI < timeDirs.size(); ++timeI)
{ {

4
applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_get_nsided_conn.H
View File

@ -1,4 +1,3 @@
int USERD_get_nsided_conn int USERD_get_nsided_conn
( (
int part_number, int part_number,
@ -13,7 +12,8 @@ int USERD_get_nsided_conn
#endif #endif
if (part_number == 1) if (part_number == 1)
{ {
Info<< "************* EEEEEEEEERRRRRRRRRRRRRRRRRR *************** " << endl << flush; Info<< "************* EEEEEEEEERRRRRRRRRRRRRRRRRR *************** "
<< endl << flush;
} }
else if (part_number < nPatches+2) else if (part_number < nPatches+2)

4
applications/utilities/postProcessing/graphics/ensightFoamReader/USERD_set_filenames.H
View File

@ -198,7 +198,8 @@ int USERD_set_filenames
runTime.setTime(timeDirs[Current_time_step], Current_time_step); runTime.setTime(timeDirs[Current_time_step], Current_time_step);
Num_variables = nVar + nSprayVariables; Num_variables = nVar + nSprayVariables;
Numparts_available = Num_unstructured_parts + Num_structured_parts + nPatches; Numparts_available =
Num_unstructured_parts + Num_structured_parts + nPatches;
#ifdef ENSIGHTDEBUG #ifdef ENSIGHTDEBUG
Info<< "Leaving: USERD_set_filenames" << endl << flush; Info<< "Leaving: USERD_set_filenames" << endl << flush;
@ -206,4 +207,3 @@ int USERD_set_filenames
return Z_OK; return Z_OK;
} }

565
applications/utilities/surface/surfaceCoarsen/bunnylod/bunnygut.C
View File

@ -1,283 +1,282 @@
/* /*
* Polygon Reduction Demo by Stan Melax (c) 1998 * Polygon Reduction Demo by Stan Melax (c) 1998
* Permission to use any of this code wherever you want is granted.. * Permission to use any of this code wherever you want is granted..
* Although, please do acknowledge authorship if appropriate. * Although, please do acknowledge authorship if appropriate.
* *
* This module initializes the bunny model data and calls * This module initializes the bunny model data and calls
* the polygon reduction routine. At each frame the RenderModel() * the polygon reduction routine. At each frame the RenderModel()
* routine is called to draw the model. This module also * routine is called to draw the model. This module also
* animates the parameters (such as number of vertices to * animates the parameters (such as number of vertices to
* use) to show the model at various levels of detail. * use) to show the model at various levels of detail.
*/ */
#include <windows.h> #include <windows.h>
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
#include <string.h> #include <string.h>
#include <GL/gl.h> #include <GL/gl.h>
#pragma warning(disable : 4244) #pragma warning(disable : 4244)
#include "vector.h" #include "vector.h"
#include "font.h" #include "font.h"
#include "progmesh.h" #include "progmesh.h"
#include "rabdata.h" #include "rabdata.h"
extern float DeltaT; // change in time since last frame extern float DeltaT; // change in time since last frame
int render_num; // number of vertices to draw with int render_num; // number of vertices to draw with
float lodbase=0.5f; // the fraction of vertices used to morph toward float lodbase=0.5f; // the fraction of vertices used to morph toward
float morph=1.0f; // where to render between 2 levels of detail float morph=1.0f; // where to render between 2 levels of detail
List<Vector> vert; // global list of vertices List<Vector> vert; // global list of vertices
List<tridata> tri; // global list of triangles List<tridata> tri; // global list of triangles
List<int> collapse_map; // to which neighbor each vertex collapses List<int> collapse_map; // to which neighbor each vertex collapses
int renderpolycount=0; // polygons rendered in the current frame int renderpolycount=0; // polygons rendered in the current frame
Vector model_position; // position of bunny Vector model_position; // position of bunny
Quaternion model_orientation; // orientation of bunny Quaternion model_orientation; // orientation of bunny
// Note that the use of the Map() function and the collapse_map // Note that the use of the Map() function and the collapse_map
// list isn't part of the polygon reduction algorithm. // list isn't part of the polygon reduction algorithm.
// We just set up this system here in this module // We just set up this system here in this module
// so that we could retrieve the model at any desired vertex count. // so that we could retrieve the model at any desired vertex count.
// Therefore if this part of the program confuses you, then // Therefore if this part of the program confuses you, then
// dont worry about it. It might help to look over the progmesh.cpp // dont worry about it. It might help to look over the progmesh.cpp
// module first. // module first.
// Map() // Map()
// //
// When the model is rendered using a maximum of mx vertices // When the model is rendered using a maximum of mx vertices
// then it is vertices 0 through mx-1 that are used. // then it is vertices 0 through mx-1 that are used.
// We are able to do this because the vertex list // We are able to do this because the vertex list
// gets sorted according to the collapse order. // gets sorted according to the collapse order.
// The Map() routine takes a vertex number 'a' and the // The Map() routine takes a vertex number 'a' and the
// maximum number of vertices 'mx' and returns the // maximum number of vertices 'mx' and returns the
// appropriate vertex in the range 0 to mx-1. // appropriate vertex in the range 0 to mx-1.
// When 'a' is greater than 'mx' the Map() routine // When 'a' is greater than 'mx' the Map() routine
// follows the chain of edge collapses until a vertex // follows the chain of edge collapses until a vertex
// within the limit is reached. // within the limit is reached.
// An example to make this clear: assume there is // An example to make this clear: assume there is
// a triangle with vertices 1, 3 and 12. But when // a triangle with vertices 1, 3 and 12. But when
// rendering the model we limit ourselves to 10 vertices. // rendering the model we limit ourselves to 10 vertices.
// In that case we find out how vertex 12 was removed // In that case we find out how vertex 12 was removed
// by the polygon reduction algorithm. i.e. which // by the polygon reduction algorithm. i.e. which
// edge was collapsed. Lets say that vertex 12 was collapsed // edge was collapsed. Lets say that vertex 12 was collapsed
// to vertex number 7. This number would have been stored // to vertex number 7. This number would have been stored
// in the collapse_map array (i.e. collapse_map[12]==7). // in the collapse_map array (i.e. collapse_map[12]==7).
// Since vertex 7 is in range (less than max of 10) we // Since vertex 7 is in range (less than max of 10) we
// will want to render the triangle 1,3,7. // will want to render the triangle 1,3,7.
// Pretend now that we want to limit ourselves to 5 vertices. // Pretend now that we want to limit ourselves to 5 vertices.
// and vertex 7 was collapsed to vertex 3 // and vertex 7 was collapsed to vertex 3
// (i.e. collapse_map[7]==3). Then triangle 1,3,12 would now be // (i.e. collapse_map[7]==3). Then triangle 1,3,12 would now be
// triangle 1,3,3. i.e. this polygon was removed by the // triangle 1,3,3. i.e. this polygon was removed by the
// progressive mesh polygon reduction algorithm by the time // progressive mesh polygon reduction algorithm by the time
// it had gotten down to 5 vertices. // it had gotten down to 5 vertices.
// No need to draw a one dimensional polygon. :-) // No need to draw a one dimensional polygon. :-)
int Map(int a,int mx) { int Map(int a,int mx) {
if(mx<=0) return 0; if(mx<=0) return 0;
while(a>=mx) { while(a>=mx) {
a=collapse_map[a]; a=collapse_map[a];
} }
return a; return a;
} }
void DrawModelTriangles() { void DrawModelTriangles() {
assert(collapse_map.num); assert(collapse_map.num);
renderpolycount=0; renderpolycount=0;
int i=0; int i=0;
for(i=0;i<tri.num;i++) { for(i=0;i<tri.num;i++) {
int p0= Map(tri[i].v[0],render_num); int p0= Map(tri[i].v[0],render_num);
int p1= Map(tri[i].v[1],render_num); int p1= Map(tri[i].v[1],render_num);
int p2= Map(tri[i].v[2],render_num); int p2= Map(tri[i].v[2],render_num);
// note: serious optimization opportunity here, // note: serious optimization opportunity here,
// by sorting the triangles the following "continue" // by sorting the triangles the following "continue"
// could have been made into a "break" statement. // could have been made into a "break" statement.
if(p0==p1 || p1==p2 || p2==p0) continue; if(p0==p1 || p1==p2 || p2==p0) continue;
renderpolycount++; renderpolycount++;
// if we are not currenly morphing between 2 levels of detail // if we are not currenly morphing between 2 levels of detail
// (i.e. if morph=1.0) then q0,q1, and q2 are not necessary. // (i.e. if morph=1.0) then q0,q1, and q2 are not necessary.
int q0= Map(p0,(int)(render_num*lodbase)); int q0= Map(p0,(int)(render_num*lodbase));
int q1= Map(p1,(int)(render_num*lodbase)); int q1= Map(p1,(int)(render_num*lodbase));
int q2= Map(p2,(int)(render_num*lodbase)); int q2= Map(p2,(int)(render_num*lodbase));
Vector v0,v1,v2; Vector v0,v1,v2;
v0 = vert[p0]*morph + vert[q0]*(1-morph); v0 = vert[p0]*morph + vert[q0]*(1-morph);
v1 = vert[p1]*morph + vert[q1]*(1-morph); v1 = vert[p1]*morph + vert[q1]*(1-morph);
v2 = vert[p2]*morph + vert[q2]*(1-morph); v2 = vert[p2]*morph + vert[q2]*(1-morph);
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
// the purpose of the demo is to show polygons // the purpose of the demo is to show polygons
// therefore just use 1 face normal (flat shading) // therefore just use 1 face normal (flat shading)
Vector nrml = (v1-v0) * (v2-v1); // cross product Vector nrml = (v1-v0) * (v2-v1); // cross product
if(0<magnitude(nrml)) { if(0<magnitude(nrml)) {
glNormal3fv(normalize(nrml)); glNormal3fv(normalize(nrml));
} }
glVertex3fv(v0); glVertex3fv(v0);
glVertex3fv(v1); glVertex3fv(v1);
glVertex3fv(v2); glVertex3fv(v2);
glEnd(); glEnd();
} }
} }
void PermuteVertices(List<int> &permutation) { void PermuteVertices(List<int> &permutation) {
// rearrange the vertex list // rearrange the vertex list
List<Vector> temp_list; List<Vector> temp_list;
int i; int i;
assert(permutation.num==vert.num); assert(permutation.num==vert.num);
for(i=0;i<vert.num;i++) { for(i=0;i<vert.num;i++) {
temp_list.Add(vert[i]); temp_list.Add(vert[i]);
} }
for(i=0;i<vert.num;i++) { for(i=0;i<vert.num;i++) {
vert[permutation[i]]=temp_list[i]; vert[permutation[i]]=temp_list[i];
} }
// update the changes in the entries in the triangle list // update the changes in the entries in the triangle list
for(i=0;i<tri.num;i++) { for(i=0;i<tri.num;i++) {
for(int j=0;j<3;j++) { for(int j=0;j<3;j++) {
tri[i].v[j] = permutation[tri[i].v[j]]; tri[i].v[j] = permutation[tri[i].v[j]];
} }
} }
} }
void GetRabbitData(){ void GetRabbitData(){
// Copy the geometry from the arrays of data in rabdata.cpp into // Copy the geometry from the arrays of data in rabdata.cpp into
// the vert and tri lists which we send to the reduction routine // the vert and tri lists which we send to the reduction routine
int i; int i;
for(i=0;i<RABBIT_VERTEX_NUM;i++) { for(i=0;i<RABBIT_VERTEX_NUM;i++) {
float *vp=rabbit_vertices[i]; float *vp=rabbit_vertices[i];
vert.Add(Vector(vp[0],vp[1],vp[2])); vert.Add(Vector(vp[0],vp[1],vp[2]));
} }
for(i=0;i<RABBIT_TRIANGLE_NUM;i++) { for(i=0;i<RABBIT_TRIANGLE_NUM;i++) {
tridata td; tridata td;
td.v[0]=rabbit_triangles[i][0]; td.v[0]=rabbit_triangles[i][0];
td.v[1]=rabbit_triangles[i][1]; td.v[1]=rabbit_triangles[i][1];
td.v[2]=rabbit_triangles[i][2]; td.v[2]=rabbit_triangles[i][2];
tri.Add(td); tri.Add(td);
} }
render_num=vert.num; // by default lets use all the model to render render_num=vert.num; // by default lets use all the model to render
} }
void InitModel() { void InitModel() {
List<int> permutation; List<int> permutation;
GetRabbitData(); GetRabbitData();
ProgressiveMesh(vert,tri,collapse_map,permutation); ProgressiveMesh(vert,tri,collapse_map,permutation);
PermuteVertices(permutation); PermuteVertices(permutation);
model_position = Vector(0,0,-3); model_position = Vector(0,0,-3);
Quaternion yaw(Vector(0,1,0),-3.14f/4); // 45 degrees Quaternion yaw(Vector(0,1,0),-3.14f/4); // 45 degrees
Quaternion pitch(Vector(1,0,0),3.14f/12); // 15 degrees Quaternion pitch(Vector(1,0,0),3.14f/12); // 15 degrees
model_orientation = pitch*yaw; model_orientation = pitch*yaw;
} }
void StatusDraw() { void StatusDraw() {
// Draw a slider type widget looking thing // Draw a slider type widget looking thing
// to show portion of vertices being used // to show portion of vertices being used
float b = (float)render_num/(float)vert.num; float b = (float)render_num/(float)vert.num;
float a = b*(lodbase ); float a = b*(lodbase );
glDisable(GL_LIGHTING); glDisable(GL_LIGHTING);
glMatrixMode( GL_PROJECTION ); glMatrixMode( GL_PROJECTION );
glPushMatrix(); glPushMatrix();
glLoadIdentity(); glLoadIdentity();
glOrtho(-0.15,15,-0.1,1.1,-0.1,100); glOrtho(-0.15,15,-0.1,1.1,-0.1,100);
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
glPushMatrix(); glPushMatrix();
glLoadIdentity(); glLoadIdentity();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(1,0,0); glColor3f(1,0,0);
glVertex2f(0,0); glVertex2f(0,0);
glVertex2f(1,0); glVertex2f(1,0);
glVertex2f(1,a); glVertex2f(1,a);
glVertex2f(0,a); glVertex2f(0,a);
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(1,0,0); glColor3f(1,0,0);
glVertex2f(0,a); glVertex2f(0,a);
glVertex2f(morph,a); glVertex2f(morph,a);
glVertex2f(morph,b); glVertex2f(morph,b);
glVertex2f(0,b); glVertex2f(0,b);
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0,0,1); glColor3f(0,0,1);
glVertex2f(morph,a); glVertex2f(morph,a);
glVertex2f(1,a); glVertex2f(1,a);
glVertex2f(1,b); glVertex2f(1,b);
glVertex2f(morph,b); glVertex2f(morph,b);
glEnd(); glEnd();
glBegin(GL_POLYGON); glBegin(GL_POLYGON);
glColor3f(0,0,1); glColor3f(0,0,1);
glVertex2f(0,b); glVertex2f(0,b);
glVertex2f(1,b); glVertex2f(1,b);
glVertex2f(1,1); glVertex2f(1,1);
glVertex2f(0,1); glVertex2f(0,1);
glEnd(); glEnd();
glPopMatrix(); glPopMatrix();
glMatrixMode( GL_PROJECTION ); glMatrixMode( GL_PROJECTION );
glPopMatrix(); glPopMatrix();
glMatrixMode( GL_MODELVIEW ); glMatrixMode( GL_MODELVIEW );
} }
/* /*
* The following is just a quick hack to animate * The following is just a quick hack to animate
* the object through various polygon reduced versions. * the object through various polygon reduced versions.
*/ */
struct keyframethings { struct keyframethings {
float t; // timestamp float t; // timestamp
float n; // portion of vertices used to start float n; // portion of vertices used to start
float dn; // rate of change in "n" float dn; // rate of change in "n"
float m; // morph value float m; // morph value
float dm; // rate of change in "m" float dm; // rate of change in "m"
} keys[]={ } keys[]={
{0 ,1 ,0 ,1, 0}, {0 ,1 ,0 ,1, 0},
{2 ,1 ,-1,1, 0}, {2 ,1 ,-1,1, 0},
{10,0 ,1 ,1, 0}, {10,0 ,1 ,1, 0},
{18,1 ,0 ,1, 0}, {18,1 ,0 ,1, 0},
{20,1 ,0 ,1,-1}, {20,1 ,0 ,1,-1},
{24,0.5 ,0 ,1, 0}, {24,0.5 ,0 ,1, 0},
{26,0.5 ,0 ,1,-1}, {26,0.5 ,0 ,1,-1},
{30,0.25,0 ,1, 0}, {30,0.25,0 ,1, 0},
{32,0.25,0 ,1,-1}, {32,0.25,0 ,1,-1},
{36,0.125,0,1, 0}, {36,0.125,0,1, 0},
{38,0.25,0 ,0, 1}, {38,0.25,0 ,0, 1},
{42,0.5 ,0 ,0, 1}, {42,0.5 ,0 ,0, 1},
{46,1 ,0 ,0, 1}, {46,1 ,0 ,0, 1},
{50,1 ,0 ,1, 0}, {50,1 ,0 ,1, 0},
}; };
void AnimateParameters() { void AnimateParameters() {
static float time=0; // global time - used for animation static float time=0; // global time - used for animation
time+=DeltaT; time+=DeltaT;
if(time>=50) time=0; // repeat cycle every so many seconds if(time>=50) time=0; // repeat cycle every so many seconds
int k=0; int k=0;
while(time>keys[k+1].t) { while(time>keys[k+1].t) {
k++; k++;
} }
float interp = (time-keys[k].t)/(keys[k+1].t-keys[k].t); float interp = (time-keys[k].t)/(keys[k+1].t-keys[k].t);
render_num = vert.num*(keys[k].n + interp*keys[k].dn); render_num = vert.num*(keys[k].n + interp*keys[k].dn);
morph = keys[k].m + interp*keys[k].dm; morph = keys[k].m + interp*keys[k].dm;
morph = (morph>1.0f) ? 1.0f : morph; // clamp value morph = (morph>1.0f) ? 1.0f : morph; // clamp value
if(render_num>vert.num) render_num=vert.num; if(render_num>vert.num) render_num=vert.num;
if(render_num<0 ) render_num=0; if(render_num<0 ) render_num=0;
} }
void RenderModel() { void RenderModel() {
AnimateParameters(); AnimateParameters();
glEnable(GL_LIGHTING); glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0); glEnable(GL_LIGHT0);
glColor3f(1,1,1); glColor3f(1,1,1);
glPushMatrix(); glPushMatrix();
glTranslatef(model_position.x,model_position.y,model_position.z); glTranslatef(model_position.x,model_position.y,model_position.z);
// Rotate by quaternion: model_orientation // Rotate by quaternion: model_orientation
Vector axis=model_orientation.axis(); Vector axis=model_orientation.axis();
float angle=model_orientation.angle()*180.0f/3.14f; float angle=model_orientation.angle()*180.0f/3.14f;
glRotatef(angle,axis.x,axis.y,axis.z); glRotatef(angle,axis.x,axis.y,axis.z);
DrawModelTriangles(); DrawModelTriangles();
StatusDraw(); StatusDraw();
glPopMatrix(); glPopMatrix();
char buf[256]; char buf[256];
sprintf(buf,"Polys: %d Vertices: %d ",renderpolycount,render_num); sprintf(buf,"Polys: %d Vertices: %d ",renderpolycount,render_num);
if(morph<1.0) { if(morph<1.0) {
sprintf(buf+strlen(buf),"<-> %d morph: %4.2f ", sprintf(buf+strlen(buf),"<-> %d morph: %4.2f ",
(int)(lodbase *render_num),morph); (int)(lodbase *render_num),morph);
} }
PostString(buf,0,-2,5); PostString(buf,0,-2,5);
} }

17
applications/utilities/surface/surfaceCoarsen/bunnylod/font.h
View File

@ -1,9 +1,8 @@
#ifndef FONT_H #ifndef FONT_H
#define FONT_H #define FONT_H
void PrintString(char *s,int x=0,int y=-1); void PrintString(char *s,int x=0,int y=-1);
void PostString(char *_s,int _x,int _y,float _life=5.0); void PostString(char *_s,int _x,int _y,float _life=5.0);
void RenderStrings(); void RenderStrings();
#endif #endif

258
applications/utilities/surface/surfaceCoarsen/bunnylod/list.h
View File

@ -1,128 +1,130 @@
/* /*
* A generic template list class. * A generic template list class.
* Fairly typical of the list example you would * Fairly typical of the list example you would
* find in any c++ book. * find in any c++ book.
*/ */
#ifndef GENERIC_LIST_H #ifndef GENERIC_LIST_H
#define GENERIC_LIST_H #define GENERIC_LIST_H
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
template <class Type> class List { template <class Type> class List {
public: public:
List(int s=0); List(int s=0);
~List(); ~List();
void allocate(int s); void allocate(int s);
void SetSize(int s); void SetSize(int s);
void Pack(); void Pack();
void Add(Type); void Add(Type);
void AddUnique(Type); void AddUnique(Type);
int Contains(Type); int Contains(Type);
void Remove(Type); void Remove(Type);
void DelIndex(int i); void DelIndex(int i);
Type * element; Type * element;
int num; int num;
int array_size; int array_size;
Type &operator[](int i){assert(i>=0 && i<num); return element[i];} Type &operator[](int i){
}; assert(i>=0 && i<num);
return element[i];}
};
template <class Type>
List<Type>::List(int s){
num=0; template <class Type>
array_size = 0; List<Type>::List(int s){
element = NULL; num=0;
if(s) { array_size = 0;
allocate(s); element = NULL;
} if(s) {
} allocate(s);
}
template <class Type> }
List<Type>::~List(){
delete element; template <class Type>
} List<Type>::~List(){
delete element;
template <class Type> }
void List<Type>::allocate(int s){
assert(s>0); template <class Type>
assert(s>=num); void List<Type>::allocate(int s){
Type *old = element; assert(s>0);
array_size =s; assert(s>=num);
element = new Type[array_size]; Type *old = element;
assert(element); array_size =s;
for(int i=0;i<num;i++){ element = new Type[array_size];
element[i]=old[i]; assert(element);
} for(int i=0;i<num;i++){
if(old) delete old; element[i]=old[i];
} }
template <class Type> if(old) delete old;
void List<Type>::SetSize(int s){ }
if(s==0) { if(element) delete element;} template <class Type>
else { allocate(s); } void List<Type>::SetSize(int s){
num=s; if(s==0) { if(element) delete element;}
} else { allocate(s); }
template <class Type> num=s;
void List<Type>::Pack(){ }
allocate(num); template <class Type>
} void List<Type>::Pack(){
allocate(num);
template <class Type> }
void List<Type>::Add(Type t){
assert(num<=array_size); template <class Type>
if(num==array_size) { void List<Type>::Add(Type t){
allocate((array_size)?array_size *2:16); assert(num<=array_size);
} if(num==array_size) {
//int i; allocate((array_size)?array_size *2:16);
//for(i=0;i<num;i++) { }
// dissallow duplicates //int i;
// assert(element[i] != t); //for(i=0;i<num;i++) {
//} // dissallow duplicates
element[num++] = t; // assert(element[i] != t);
} //}
element[num++] = t;
template <class Type> }
int List<Type>::Contains(Type t){
int i; template <class Type>
int count=0; int List<Type>::Contains(Type t){
for(i=0;i<num;i++) { int i;
if(element[i] == t) count++; int count=0;
} for(i=0;i<num;i++) {
return count; if(element[i] == t) count++;
} }
return count;
template <class Type> }
void List<Type>::AddUnique(Type t){
if(!Contains(t)) Add(t); template <class Type>
} void List<Type>::AddUnique(Type t){
if(!Contains(t)) Add(t);
}
template <class Type>
void List<Type>::DelIndex(int i){
assert(i<num); template <class Type>
num--; void List<Type>::DelIndex(int i){
while(i<num){ assert(i<num);
element[i] = element[i+1]; num--;
i++; while(i<num){
} element[i] = element[i+1];
} i++;
}
template <class Type> }
void List<Type>::Remove(Type t){
int i; template <class Type>
for(i=0;i<num;i++) { void List<Type>::Remove(Type t){
if(element[i] == t) { int i;
break; for(i=0;i<num;i++) {
} if(element[i] == t) {
} break;
DelIndex(i); }
for(i=0;i<num;i++) { }
assert(element[i] != t); DelIndex(i);
} for(i=0;i<num;i++) {
} assert(element[i] != t);
}
}
#endif
#endif

628
applications/utilities/surface/surfaceCoarsen/bunnylod/progmesh.C
View File

@ -1,313 +1,315 @@
/* /*
* Progressive Mesh type Polygon Reduction Algorithm * Progressive Mesh type Polygon Reduction Algorithm
* by Stan Melax (c) 1998 * by Stan Melax (c) 1998
* Permission to use any of this code wherever you want is granted.. * Permission to use any of this code wherever you want is granted..
* Although, please do acknowledge authorship if appropriate. * Although, please do acknowledge authorship if appropriate.
* *
* See the header file progmesh.h for a description of this module * See the header file progmesh.h for a description of this module
*/ */
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include <assert.h> #include <assert.h>
//#include <windows.h> //#include <windows.h>
#include "vector.h" #include "vector.h"
#include "list.h" #include "list.h"
#include "progmesh.h" #include "progmesh.h"
#define min(x,y) (((x) <= (y)) ? (x) : (y)) #define min(x,y) (((x) <= (y)) ? (x) : (y))
#define max(x,y) (((x) >= (y)) ? (x) : (y)) #define max(x,y) (((x) >= (y)) ? (x) : (y))
/* /*
* For the polygon reduction algorithm we use data structures * For the polygon reduction algorithm we use data structures
* that contain a little bit more information than the usual * that contain a little bit more information than the usual
* indexed face set type of data structure. * indexed face set type of data structure.
* From a vertex we wish to be able to quickly get the * From a vertex we wish to be able to quickly get the
* neighboring faces and vertices. * neighboring faces and vertices.
*/ */
class Triangle; class Triangle;
class Vertex; class Vertex;
class Triangle { class Triangle {
public: public:
Vertex * vertex[3]; // the 3 points that make this tri Vertex * vertex[3]; // the 3 points that make this tri
Vector normal; // unit vector othogonal to this face Vector normal; // unit vector othogonal to this face
Triangle(Vertex *v0,Vertex *v1,Vertex *v2); Triangle(Vertex *v0,Vertex *v1,Vertex *v2);
~Triangle(); ~Triangle();
void ComputeNormal(); void ComputeNormal();
void ReplaceVertex(Vertex *vold,Vertex *vnew); void ReplaceVertex(Vertex *vold,Vertex *vnew);
int HasVertex(Vertex *v); int HasVertex(Vertex *v);
}; };
class Vertex { class Vertex {
public: public:
Vector position; // location of point in euclidean space Vector position; // location of point in euclidean space
int id; // place of vertex in original list int id; // place of vertex in original list
List<Vertex *> neighbor; // adjacent vertices List<Vertex *> neighbor; // adjacent vertices
List<Triangle *> face; // adjacent triangles List<Triangle *> face; // adjacent triangles
float objdist; // cached cost of collapsing edge float objdist; // cached cost of collapsing edge
Vertex * collapse; // candidate vertex for collapse Vertex * collapse; // candidate vertex for collapse
Vertex(Vector v,int _id); Vertex(Vector v,int _id);
~Vertex(); ~Vertex();
void RemoveIfNonNeighbor(Vertex *n); void RemoveIfNonNeighbor(Vertex *n);
}; };
List<Vertex *> vertices; List<Vertex *> vertices;
List<Triangle *> triangles; List<Triangle *> triangles;
Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){ Triangle::Triangle(Vertex *v0,Vertex *v1,Vertex *v2){
assert(v0!=v1 && v1!=v2 && v2!=v0); assert(v0!=v1 && v1!=v2 && v2!=v0);
vertex[0]=v0; vertex[0]=v0;
vertex[1]=v1; vertex[1]=v1;
vertex[2]=v2; vertex[2]=v2;
ComputeNormal(); ComputeNormal();
triangles.Add(this); triangles.Add(this);
for(int i=0;i<3;i++) { for(int i=0;i<3;i++) {
vertex[i]->face.Add(this); vertex[i]->face.Add(this);
for(int j=0;j<3;j++) if(i!=j) { for(int j=0;j<3;j++) if(i!=j) {
vertex[i]->neighbor.AddUnique(vertex[j]); vertex[i]->neighbor.AddUnique(vertex[j]);
} }
} }
} }
Triangle::~Triangle(){ Triangle::~Triangle(){
int i; int i;
triangles.Remove(this); triangles.Remove(this);
for(i=0;i<3;i++) { for(i=0;i<3;i++) {
if(vertex[i]) vertex[i]->face.Remove(this); if(vertex[i]) vertex[i]->face.Remove(this);
} }
for(i=0;i<3;i++) { for(i=0;i<3;i++) {
int i2 = (i+1)%3; int i2 = (i+1)%3;
if(!vertex[i] || !vertex[i2]) continue; if(!vertex[i] || !vertex[i2]) continue;
vertex[i ]->RemoveIfNonNeighbor(vertex[i2]); vertex[i ]->RemoveIfNonNeighbor(vertex[i2]);
vertex[i2]->RemoveIfNonNeighbor(vertex[i ]); vertex[i2]->RemoveIfNonNeighbor(vertex[i ]);
} }
} }
int Triangle::HasVertex(Vertex *v) { int Triangle::HasVertex(Vertex *v) {
return (v==vertex[0] ||v==vertex[1] || v==vertex[2]); return (v==vertex[0] ||v==vertex[1] || v==vertex[2]);
} }
void Triangle::ComputeNormal(){ void Triangle::ComputeNormal(){
Vector v0=vertex[0]->position; Vector v0=vertex[0]->position;
Vector v1=vertex[1]->position; Vector v1=vertex[1]->position;
Vector v2=vertex[2]->position; Vector v2=vertex[2]->position;
normal = (v1-v0)*(v2-v1); normal = (v1-v0)*(v2-v1);
if(magnitude(normal)==0)return; if(magnitude(normal)==0)return;
normal = normalize(normal); normal = normalize(normal);
} }
void Triangle::ReplaceVertex(Vertex *vold,Vertex *vnew) { void Triangle::ReplaceVertex(Vertex *vold,Vertex *vnew) {
assert(vold && vnew); assert(vold && vnew);
assert(vold==vertex[0] || vold==vertex[1] || vold==vertex[2]); assert(vold==vertex[0] || vold==vertex[1] || vold==vertex[2]);
assert(vnew!=vertex[0] && vnew!=vertex[1] && vnew!=vertex[2]); assert(vnew!=vertex[0] && vnew!=vertex[1] && vnew!=vertex[2]);
if(vold==vertex[0]){ if(vold==vertex[0]){
vertex[0]=vnew; vertex[0]=vnew;
} }
else if(vold==vertex[1]){ else if(vold==vertex[1]){
vertex[1]=vnew; vertex[1]=vnew;
} }
else { else {
assert(vold==vertex[2]); assert(vold==vertex[2]);
vertex[2]=vnew; vertex[2]=vnew;
} }
int i; int i;
vold->face.Remove(this); vold->face.Remove(this);
assert(!vnew->face.Contains(this)); assert(!vnew->face.Contains(this));
vnew->face.Add(this); vnew->face.Add(this);
for(i=0;i<3;i++) { for(i=0;i<3;i++) {
vold->RemoveIfNonNeighbor(vertex[i]); vold->RemoveIfNonNeighbor(vertex[i]);
vertex[i]->RemoveIfNonNeighbor(vold); vertex[i]->RemoveIfNonNeighbor(vold);
} }
for(i=0;i<3;i++) { for(i=0;i<3;i++) {
assert(vertex[i]->face.Contains(this)==1); assert(vertex[i]->face.Contains(this)==1);
for(int j=0;j<3;j++) if(i!=j) { for(int j=0;j<3;j++) if(i!=j) {
vertex[i]->neighbor.AddUnique(vertex[j]); vertex[i]->neighbor.AddUnique(vertex[j]);
} }
} }
ComputeNormal(); ComputeNormal();
} }
Vertex::Vertex(Vector v,int _id) { Vertex::Vertex(Vector v,int _id) {
position =v; position =v;
id=_id; id=_id;
vertices.Add(this); vertices.Add(this);
} }
Vertex::~Vertex(){ Vertex::~Vertex(){
assert(face.num==0); assert(face.num==0);
while(neighbor.num) { while(neighbor.num) {
neighbor[0]->neighbor.Remove(this); neighbor[0]->neighbor.Remove(this);
neighbor.Remove(neighbor[0]); neighbor.Remove(neighbor[0]);
} }
vertices.Remove(this); vertices.Remove(this);
} }
void Vertex::RemoveIfNonNeighbor(Vertex *n) { void Vertex::RemoveIfNonNeighbor(Vertex *n) {
// removes n from neighbor list if n isn't a neighbor. // removes n from neighbor list if n isn't a neighbor.
if(!neighbor.Contains(n)) return; if(!neighbor.Contains(n)) return;
for(int i=0;i<face.num;i++) { for(int i=0;i<face.num;i++) {
if(face[i]->HasVertex(n)) return; if(face[i]->HasVertex(n)) return;
} }
neighbor.Remove(n); neighbor.Remove(n);
} }
float ComputeEdgeCollapseCost(Vertex *u,Vertex *v) { float ComputeEdgeCollapseCost(Vertex *u,Vertex *v) {
// if we collapse edge uv by moving u to v then how // if we collapse edge uv by moving u to v then how
// much different will the model change, i.e. how much "error". // much different will the model change, i.e. how much "error".
// Texture, vertex normal, and border vertex code was removed // Texture, vertex normal, and border vertex code was removed
// to keep this demo as simple as possible. // to keep this demo as simple as possible.
// The method of determining cost was designed in order // The method of determining cost was designed in order
// to exploit small and coplanar regions for // to exploit small and coplanar regions for
// effective polygon reduction. // effective polygon reduction.
// Is is possible to add some checks here to see if "folds" // Is is possible to add some checks here to see if "folds"
// would be generated. i.e. normal of a remaining face gets // would be generated. i.e. normal of a remaining face gets
// flipped. I never seemed to run into this problem and // flipped. I never seemed to run into this problem and
// therefore never added code to detect this case. // therefore never added code to detect this case.
int i; int i;
float edgelength = magnitude(v->position - u->position); float edgelength = magnitude(v->position - u->position);
float curvature=0; float curvature=0;
// find the "sides" triangles that are on the edge uv // find the "sides" triangles that are on the edge uv
List<Triangle *> sides; List<Triangle *> sides;
for(i=0;i<u->face.num;i++) { for(i=0;i<u->face.num;i++) {
if(u->face[i]->HasVertex(v)){ if(u->face[i]->HasVertex(v)){
sides.Add(u->face[i]); sides.Add(u->face[i]);
} }
} }
// use the triangle facing most away from the sides // use the triangle facing most away from the sides
// to determine our curvature term // to determine our curvature term
for(i=0;i<u->face.num;i++) { for(i=0;i<u->face.num;i++) {
float mincurv=1; // curve for face i and closer side to it float mincurv=1; // curve for face i and closer side to it
for(int j=0;j<sides.num;j++) { for(int j=0;j<sides.num;j++) {
// use dot product of face normals. '^' defined in vector // use dot product of face normals. '^'
float dotprod = u->face[i]->normal ^ sides[j]->normal; // defined in vector
mincurv = min(mincurv,(1-dotprod)/2.0f); float dotprod = u->face[i]->normal ^ sides[j]->normal;
} mincurv = min(mincurv,(1-dotprod)/2.0f);
curvature = max(curvature,mincurv); }
} curvature = max(curvature,mincurv);
// the more coplanar the lower the curvature term }
return edgelength * curvature; // the more coplanar the lower the curvature term
} return edgelength * curvature;
}
void ComputeEdgeCostAtVertex(Vertex *v) {
// compute the edge collapse cost for all edges that start void ComputeEdgeCostAtVertex(Vertex *v) {
// from vertex v. Since we are only interested in reducing // compute the edge collapse cost for all edges that start
// the object by selecting the min cost edge at each step, we // from vertex v. Since we are only interested in reducing
// only cache the cost of the least cost edge at this vertex // the object by selecting the min cost edge at each step, we
// (in member variable collapse) as well as the value of the // only cache the cost of the least cost edge at this vertex
// cost (in member variable objdist). // (in member variable collapse) as well as the value of the
if(v->neighbor.num==0) { // cost (in member variable objdist).
// v doesn't have neighbors so it costs nothing to collapse if(v->neighbor.num==0) {
v->collapse=NULL; // v doesn't have neighbors so it costs nothing to collapse
v->objdist=-0.01f; v->collapse=NULL;
return; v->objdist=-0.01f;
} return;
v->objdist = 1000000; }
v->collapse=NULL; v->objdist = 1000000;
// search all neighboring edges for "least cost" edge v->collapse=NULL;
for(int i=0;i<v->neighbor.num;i++) { // search all neighboring edges for "least cost" edge
float dist; for(int i=0;i<v->neighbor.num;i++) {
dist = ComputeEdgeCollapseCost(v,v->neighbor[i]); float dist;
if(dist<v->objdist) { dist = ComputeEdgeCollapseCost(v,v->neighbor[i]);
v->collapse=v->neighbor[i]; // candidate for edge collapse if(dist<v->objdist) {
v->objdist=dist; // cost of the collapse // candidate for edge collapse
} v->collapse=v->neighbor[i];
} // cost of the collapse
} v->objdist=dist;
void ComputeAllEdgeCollapseCosts() { }
// For all the edges, compute the difference it would make }
// to the model if it was collapsed. The least of these }
// per vertex is cached in each vertex object. void ComputeAllEdgeCollapseCosts() {
for(int i=0;i<vertices.num;i++) { // For all the edges, compute the difference it would make
ComputeEdgeCostAtVertex(vertices[i]); // to the model if it was collapsed. The least of these
} // per vertex is cached in each vertex object.
} for(int i=0;i<vertices.num;i++) {
ComputeEdgeCostAtVertex(vertices[i]);
void Collapse(Vertex *u,Vertex *v){ }
// Collapse the edge uv by moving vertex u onto v }
// Actually remove tris on uv, then update tris that
// have u to have v, and then remove u. void Collapse(Vertex *u,Vertex *v){
if(!v) { // Collapse the edge uv by moving vertex u onto v
// u is a vertex all by itself so just delete it // Actually remove tris on uv, then update tris that
delete u; // have u to have v, and then remove u.
return; if(!v) {
} // u is a vertex all by itself so just delete it
int i; delete u;
List<Vertex *>tmp; return;
// make tmp a list of all the neighbors of u }
for(i=0;i<u->neighbor.num;i++) { int i;
tmp.Add(u->neighbor[i]); List<Vertex *>tmp;
} // make tmp a list of all the neighbors of u
// delete triangles on edge uv: for(i=0;i<u->neighbor.num;i++) {
for(i=u->face.num-1;i>=0;i--) { tmp.Add(u->neighbor[i]);
if(u->face[i]->HasVertex(v)) { }
delete(u->face[i]); // delete triangles on edge uv:
} for(i=u->face.num-1;i>=0;i--) {
} if(u->face[i]->HasVertex(v)) {
// update remaining triangles to have v instead of u delete(u->face[i]);
for(i=u->face.num-1;i>=0;i--) { }
u->face[i]->ReplaceVertex(u,v); }
} // update remaining triangles to have v instead of u
delete u; for(i=u->face.num-1;i>=0;i--) {
// recompute the edge collapse costs for neighboring vertices u->face[i]->ReplaceVertex(u,v);
for(i=0;i<tmp.num;i++) { }
ComputeEdgeCostAtVertex(tmp[i]); delete u;
} // recompute the edge collapse costs for neighboring vertices
} for(i=0;i<tmp.num;i++) {
ComputeEdgeCostAtVertex(tmp[i]);
void AddVertex(List<Vector> &vert){ }
for(int i=0;i<vert.num;i++) { }
new Vertex(vert[i],i);
} void AddVertex(List<Vector> &vert){
} for(int i=0;i<vert.num;i++) {
void AddFaces(List<tridata> &tri){ new Vertex(vert[i],i);
for(int i=0;i<tri.num;i++) { }
new Triangle( }
vertices[tri[i].v[0]], void AddFaces(List<tridata> &tri){
vertices[tri[i].v[1]], for(int i=0;i<tri.num;i++) {
vertices[tri[i].v[2]] ); new Triangle(
} vertices[tri[i].v[0]],
} vertices[tri[i].v[1]],
vertices[tri[i].v[2]] );
Vertex *MinimumCostEdge(){ }
// Find the edge that when collapsed will affect model the least. }
// This funtion actually returns a Vertex, the second vertex
// of the edge (collapse candidate) is stored in the vertex data. Vertex *MinimumCostEdge(){
// Serious optimization opportunity here: this function currently // Find the edge that when collapsed will affect model the least.
// does a sequential search through an unsorted list :-( // This funtion actually returns a Vertex, the second vertex
// Our algorithm could be O(n*lg(n)) instead of O(n*n) // of the edge (collapse candidate) is stored in the vertex data.
Vertex *mn=vertices[0]; // Serious optimization opportunity here: this function currently
for(int i=0;i<vertices.num;i++) { // does a sequential search through an unsorted list :-(
if(vertices[i]->objdist < mn->objdist) { // Our algorithm could be O(n*lg(n)) instead of O(n*n)
mn = vertices[i]; Vertex *mn=vertices[0];
} for(int i=0;i<vertices.num;i++) {
} if(vertices[i]->objdist < mn->objdist) {
return mn; mn = vertices[i];
} }
}
void ProgressiveMesh(List<Vector> &vert, List<tridata> &tri, return mn;
List<int> &map, List<int> &permutation) }
{
AddVertex(vert); // put input data into our data structures void ProgressiveMesh(List<Vector> &vert, List<tridata> &tri,
AddFaces(tri); List<int> &map, List<int> &permutation)
ComputeAllEdgeCollapseCosts(); // cache all edge collapse costs {
permutation.SetSize(vertices.num); // allocate space AddVertex(vert); // put input data into our data structures
map.SetSize(vertices.num); // allocate space AddFaces(tri);
// reduce the object down to nothing: ComputeAllEdgeCollapseCosts(); // cache all edge collapse costs
while(vertices.num > 0) { permutation.SetSize(vertices.num); // allocate space
// get the next vertex to collapse map.SetSize(vertices.num); // allocate space
Vertex *mn = MinimumCostEdge(); // reduce the object down to nothing:
// keep track of this vertex, i.e. the collapse ordering while(vertices.num > 0) {
permutation[mn->id]=vertices.num-1; // get the next vertex to collapse
// keep track of vertex to which we collapse to Vertex *mn = MinimumCostEdge();
map[vertices.num-1] = (mn->collapse)?mn->collapse->id:-1; // keep track of this vertex, i.e. the collapse ordering
// Collapse this edge permutation[mn->id]=vertices.num-1;
Collapse(mn,mn->collapse); // keep track of vertex to which we collapse to
} map[vertices.num-1] = (mn->collapse)?mn->collapse->id:-1;
// reorder the map list based on the collapse ordering // Collapse this edge
for(int i=0;i<map.num;i++) { Collapse(mn,mn->collapse);
map[i] = (map[i]==-1)?0:permutation[map[i]]; }
} // reorder the map list based on the collapse ordering
// The caller of this function should reorder their vertices for(int i=0;i<map.num;i++) {
// according to the returned "permutation". map[i] = (map[i]==-1)?0:permutation[map[i]];
} }
// The caller of this function should reorder their vertices
// according to the returned "permutation".
}

66
applications/utilities/surface/surfaceCoarsen/bunnylod/progmesh.h
View File

@ -1,33 +1,33 @@
/* /*
* Progressive Mesh type Polygon Reduction Algorithm * Progressive Mesh type Polygon Reduction Algorithm
* by Stan Melax (c) 1998 * by Stan Melax (c) 1998
* *
* The function ProgressiveMesh() takes a model in an "indexed face * The function ProgressiveMesh() takes a model in an "indexed face
* set" sort of way. i.e. list of vertices and list of triangles. * set" sort of way. i.e. list of vertices and list of triangles.
* The function then does the polygon reduction algorithm * The function then does the polygon reduction algorithm
* internally and reduces the model all the way down to 0 * internally and reduces the model all the way down to 0
* vertices and then returns the order in which the * vertices and then returns the order in which the
* vertices are collapsed and to which neighbor each vertex * vertices are collapsed and to which neighbor each vertex
* is collapsed to. More specifically the returned "permutation" * is collapsed to. More specifically the returned "permutation"
* indicates how to reorder your vertices so you can render * indicates how to reorder your vertices so you can render
* an object by using the first n vertices (for the n * an object by using the first n vertices (for the n
* vertex version). After permuting your vertices, the * vertex version). After permuting your vertices, the
* map list indicates to which vertex each vertex is collapsed to. * map list indicates to which vertex each vertex is collapsed to.
*/ */
#ifndef PROGRESSIVE_MESH_H #ifndef PROGRESSIVE_MESH_H
#define PROGRESSIVE_MESH_H #define PROGRESSIVE_MESH_H
#include "vector.h" #include "vector.h"
#include "list.h" #include "list.h"
class tridata { class tridata {
public: public:
int v[3]; // indices to vertex list int v[3]; // indices to vertex list
// texture and vertex normal info removed for this demo // texture and vertex normal info removed for this demo
}; };
void ProgressiveMesh(List<Vector> &vert, List<tridata> &tri, void ProgressiveMesh(List<Vector> &vert, List<tridata> &tri,
List<int> &map, List<int> &permutation ); List<int> &map, List<int> &permutation );
#endif #endif

2765
applications/utilities/surface/surfaceCoarsen/bunnylod/rabdata.C
View File

File diff suppressed because it is too large Load Diff

63
applications/utilities/surface/surfaceCoarsen/bunnylod/rabdata.h
View File

@ -1,31 +1,32 @@
/* Copyright 1996, Viewpoint Datalabs Int'l, www.viewpoint.com, 1-800-DATASET */ /* Copyright 1996, Viewpoint Datalabs Int'l, www.viewpoint.com, 1-800-DATASET */
/* /*
# Usage Rights: You (the user) may use this model to help build cool personal # Usage Rights: You (the user) may use this model to help build
# vrml worlds, but please give us credit when you do ("3D model provided by # cool personal vrml worlds, but please give us credit when you do
# Viewpoint Datalabs, www,viewpoint.com"). Please don't sell it or use it to # ("3D model provided by Viewpoint Datalabs, www,viewpoint.com").
# make money indirectly. Don't redistribute it or put it on a web site except # Please don't sell it or use it to make money indirectly. Don't
# as a part of your personal, non-commerical vrml world. If you want to do a # redistribute it or put it on a web site except as a part of your
# commercial project, give us a call at 1-800-DATASET or visit www.viewpoint.com # personal, non-commerical vrml world. If you want to do a
# and we'll help you obtain the rights to do so. # commercial project, give us a call at 1-800-DATASET or visit
*/ # www.viewpoint.com and we'll help you obtain the rights to do so.
# */
/*
* Note that this data was put directly into the program /*
* to provide a demo program on the net that people could * Note that this data was put directly into the program
* just run without having to fetch datafiles. * to provide a demo program on the net that people could
* i.e. more convienent for the user this way * just run without having to fetch datafiles.
*/ * i.e. more convienent for the user this way
*/
#ifndef RABBIT_DATA_H
#define RABBIT_DATA_H #ifndef RABBIT_DATA_H
#define RABBIT_DATA_H
#define RABBIT_VERTEX_NUM (453)
#define RABBIT_TRIANGLE_NUM (902) #define RABBIT_VERTEX_NUM (453)
#define RABBIT_TRIANGLE_NUM (902)
extern float rabbit_vertices[RABBIT_VERTEX_NUM][3];
extern int rabbit_triangles[RABBIT_TRIANGLE_NUM][3]; extern float rabbit_vertices[RABBIT_VERTEX_NUM][3];
extern int rabbit_triangles[RABBIT_TRIANGLE_NUM][3];
#endif
#endif

225
applications/utilities/surface/surfaceCoarsen/bunnylod/vector.C
View File

@ -1,108 +1,117 @@
#include <stdio.h>
#include <stdio.h> #include <math.h>
#include <math.h> #include <assert.h>
#include <assert.h>
#include "vector.h"
#include "vector.h"
float sqr(float a) {return a*a;}
float sqr(float a) {return a*a;}
// vector (floating point) implementation
// vector (floating point) implementation
float magnitude(Vector v) {
float magnitude(Vector v) { return float(sqrt(sqr(v.x) + sqr( v.y)+ sqr(v.z)));
return float(sqrt(sqr(v.x) + sqr( v.y)+ sqr(v.z))); }
} Vector normalize(Vector v) {
Vector normalize(Vector v) { float d=magnitude(v);
float d=magnitude(v); if (d==0) {
if (d==0) { printf("Cant normalize ZERO vector\n");
printf("Cant normalize ZERO vector\n"); assert(0);
assert(0); d=0.1f;
d=0.1f; }
} v.x/=d;
v.x/=d; v.y/=d;
v.y/=d; v.z/=d;
v.z/=d; return v;
return v; }
}
Vector operator+(Vector v1,Vector v2)
Vector operator+(Vector v1,Vector v2) {return Vector(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z);} {
Vector operator-(Vector v1,Vector v2) {return Vector(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z);} return Vector(v1.x+v2.x,v1.y+v2.y,v1.z+v2.z);
Vector operator-(Vector v) {return Vector(-v.x,-v.y,-v.z);} }
Vector operator*(Vector v1,float s) {return Vector(v1.x*s,v1.y*s,v1.z*s);} Vector operator-(Vector v1,Vector v2)
Vector operator*(float s, Vector v1) {return Vector(v1.x*s,v1.y*s,v1.z*s);} {
Vector operator/(Vector v1,float s) {return v1*(1.0f/s);} return Vector(v1.x-v2.x,v1.y-v2.y,v1.z-v2.z);
float operator^(Vector v1,Vector v2) {return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;} }
Vector operator*(Vector v1,Vector v2) { Vector operator-(Vector v) {return Vector(-v.x,-v.y,-v.z);}
return Vector( Vector operator*(Vector v1,float s) {return Vector(v1.x*s,v1.y*s,v1.z*s);}
v1.y * v2.z - v1.z*v2.y, Vector operator*(float s, Vector v1) {return Vector(v1.x*s,v1.y*s,v1.z*s);}
v1.z * v2.x - v1.x*v2.z, Vector operator/(Vector v1,float s) {return v1*(1.0f/s);}
v1.x * v2.y - v1.y*v2.x); float operator^(Vector v1,Vector v2)
} {
Vector planelineintersection(Vector n,float d,Vector p1,Vector p2){ return v1.x*v2.x + v1.y*v2.y + v1.z*v2.z;
// returns the point where the line p1-p2 intersects the plane n&d }
Vector dif = p2-p1; Vector operator*(Vector v1,Vector v2) {
float dn= n^dif; return Vector(
float t = -(d+(n^p1) )/dn; v1.y * v2.z - v1.z*v2.y,
return p1 + (dif*t); v1.z * v2.x - v1.x*v2.z,
} v1.x * v2.y - v1.y*v2.x);
int concurrent(Vector a,Vector b) { }
return(a.x==b.x && a.y==b.y && a.z==b.z); Vector planelineintersection(Vector n,float d,Vector p1,Vector p2){
} // returns the point where the line p1-p2 intersects the plane n&d
Vector dif = p2-p1;
float dn= n^dif;
// Matrix Implementation float t = -(d+(n^p1) )/dn;
matrix transpose(matrix m) { return p1 + (dif*t);
return matrix( Vector(m.x.x,m.y.x,m.z.x), }
Vector(m.x.y,m.y.y,m.z.y), int concurrent(Vector a,Vector b) {
Vector(m.x.z,m.y.z,m.z.z)); return(a.x==b.x && a.y==b.y && a.z==b.z);
} }
Vector operator*(matrix m,Vector v){
m=transpose(m); // since column ordered
return Vector(m.x^v,m.y^v,m.z^v); // Matrix Implementation
} matrix transpose(matrix m) {
matrix operator*(matrix m1,matrix m2){ return matrix( Vector(m.x.x,m.y.x,m.z.x),
m1=transpose(m1); Vector(m.x.y,m.y.y,m.z.y),
return matrix(m1*m2.x,m1*m2.y,m1*m2.z); Vector(m.x.z,m.y.z,m.z.z));
} }
Vector operator*(matrix m,Vector v){
//Quaternion Implementation m=transpose(m); // since column ordered
Quaternion operator*(Quaternion a,Quaternion b) { return Vector(m.x^v,m.y^v,m.z^v);
Quaternion c; }
c.r = a.r*b.r - a.x*b.x - a.y*b.y - a.z*b.z; matrix operator*(matrix m1,matrix m2){
c.x = a.r*b.x + a.x*b.r + a.y*b.z - a.z*b.y; m1=transpose(m1);
c.y = a.r*b.y - a.x*b.z + a.y*b.r + a.z*b.x; return matrix(m1*m2.x,m1*m2.y,m1*m2.z);
c.z = a.r*b.z + a.x*b.y - a.y*b.x + a.z*b.r; }
return c;
} //Quaternion Implementation
Quaternion operator-(Quaternion q) { Quaternion operator*(Quaternion a,Quaternion b) {
return Quaternion(q.r*-1,q.x,q.y,q.z); Quaternion c;
} c.r = a.r*b.r - a.x*b.x - a.y*b.y - a.z*b.z;
Quaternion operator*(Quaternion a,float b) { c.x = a.r*b.x + a.x*b.r + a.y*b.z - a.z*b.y;
return Quaternion(a.r*b, a.x*b, a.y*b, a.z*b); c.y = a.r*b.y - a.x*b.z + a.y*b.r + a.z*b.x;
} c.z = a.r*b.z + a.x*b.y - a.y*b.x + a.z*b.r;
Vector operator*(Quaternion q,Vector v) { return c;
return q.getmatrix() * v; }
} Quaternion operator-(Quaternion q) {
Vector operator*(Vector v,Quaternion q){ return Quaternion(q.r*-1,q.x,q.y,q.z);
assert(0); // must multiply with the quat on the left }
return Vector(0.0f,0.0f,0.0f); Quaternion operator*(Quaternion a,float b) {
} return Quaternion(a.r*b, a.x*b, a.y*b, a.z*b);
}
Quaternion operator+(Quaternion a,Quaternion b) { Vector operator*(Quaternion q,Vector v) {
return Quaternion(a.r+b.r, a.x+b.x, a.y+b.y, a.z+b.z); return q.getmatrix() * v;
} }
float operator^(Quaternion a,Quaternion b) { Vector operator*(Vector v,Quaternion q){
return (a.r*b.r + a.x*b.x + a.y*b.y + a.z*b.z); assert(0); // must multiply with the quat on the left
} return Vector(0.0f,0.0f,0.0f);
Quaternion slerp(Quaternion a,Quaternion b,float interp){ }
if((a^b) <0.0) {
a.r=-a.r; Quaternion operator+(Quaternion a,Quaternion b) {
a.x=-a.x; return Quaternion(a.r+b.r, a.x+b.x, a.y+b.y, a.z+b.z);
a.y=-a.y; }
a.z=-a.z; float operator^(Quaternion a,Quaternion b) {
} return (a.r*b.r + a.x*b.x + a.y*b.y + a.z*b.z);
float theta = float(acos(a^b)); }
if(theta==0.0f) { return(a);} Quaternion slerp(Quaternion a,Quaternion b,float interp){
return a*float(sin(theta-interp*theta)/sin(theta)) + b*float(sin(interp*theta)/sin(theta)); if((a^b) <0.0) {
} a.r=-a.r;
a.x=-a.x;
a.y=-a.y;
a.z=-a.z;
}
float theta = float(acos(a^b));
if(theta==0.0f) { return(a);}
return
a*float(sin(theta-interp*theta)/sin(theta))
+ b*float(sin(interp*theta)/sin(theta));
}

145
applications/utilities/surface/surfaceCoarsen/bunnylod/vector.h
View File

@ -1,66 +1,79 @@
// //
// This module contains a bunch of well understood functions // This module contains a bunch of well understood functions
// I apologise if the conventions used here are slightly // I apologise if the conventions used here are slightly
// different than what you are used to. // different than what you are used to.
// //
#ifndef GENERIC_VECTOR_H #ifndef GENERIC_VECTOR_H
#define GENERIC_VECTOR_H #define GENERIC_VECTOR_H
#include <stdio.h> #include <stdio.h>
#include <math.h> #include <math.h>
class Vector { class Vector {
public: public:
float x,y,z; float x,y,z;
Vector(float _x=0.0,float _y=0.0,float _z=0.0){x=_x;y=_y;z=_z;}; Vector(float _x=0.0,float _y=0.0,float _z=0.0){x=_x;y=_y;z=_z;};
operator float *() { return &x;}; operator float *() { return &x;};
}; };
float magnitude(Vector v); float magnitude(Vector v);
Vector normalize(Vector v); Vector normalize(Vector v);
Vector operator+(Vector v1,Vector v2); Vector operator+(Vector v1,Vector v2);
Vector operator-(Vector v); Vector operator-(Vector v);
Vector operator-(Vector v1,Vector v2); Vector operator-(Vector v1,Vector v2);
Vector operator*(Vector v1,float s) ; Vector operator*(Vector v1,float s) ;
Vector operator*(float s,Vector v1) ; Vector operator*(float s,Vector v1) ;
Vector operator/(Vector v1,float s) ; Vector operator/(Vector v1,float s) ;
float operator^(Vector v1,Vector v2); // DOT product float operator^(Vector v1,Vector v2); // DOT product
Vector operator*(Vector v1,Vector v2); // CROSS product Vector operator*(Vector v1,Vector v2); // CROSS product
Vector planelineintersection(Vector n,float d,Vector p1,Vector p2); Vector planelineintersection(Vector n,float d,Vector p1,Vector p2);
class matrix{ class matrix{
public: public:
Vector x,y,z; Vector x,y,z;
matrix(){x=Vector(1.0f,0.0f,0.0f); matrix(){x=Vector(1.0f,0.0f,0.0f);
y=Vector(0.0f,1.0f,0.0f); y=Vector(0.0f,1.0f,0.0f);
z=Vector(0.0f,0.0f,1.0f);}; z=Vector(0.0f,0.0f,1.0f);};
matrix(Vector _x,Vector _y,Vector _z){x=_x;y=_y;z=_z;}; matrix(Vector _x,Vector _y,Vector _z){x=_x;y=_y;z=_z;};
}; };
matrix transpose(matrix m); matrix transpose(matrix m);
Vector operator*(matrix m,Vector v); Vector operator*(matrix m,Vector v);
matrix operator*(matrix m1,matrix m2); matrix operator*(matrix m1,matrix m2);
class Quaternion{ class Quaternion{
public: public:
float r,x,y,z; float r,x,y,z;
Quaternion(){x=y=z=0.0f;r=1.0f;}; Quaternion(){x=y=z=0.0f;r=1.0f;};
Quaternion(Vector v,float t){v=normalize(v);r=float(cos(t/2.0));v=v*float(sin(t/2.0));x=v.x;y=v.y;z=v.z;}; Quaternion(Vector v,float t){
Quaternion(float _r,float _x,float _y,float _z){r=_r;x=_x;y=_y;z=_z;}; v=normalize(v);
float angle(){return float(acos(r)*2.0);} r=float(cos(t/2.0));
Vector axis(){Vector a(x,y,z); return a*float(1/sin(angle()/2.0));} v=v*float(sin(t/2.0));
Vector xdir(){return Vector(1-2*(y*y+z*z), 2*(x*y+r*z), 2*(x*z-r*y));} x=v.x;
Vector ydir(){return Vector( 2*(x*y-r*z),1-2*(x*x+z*z), 2*(y*z+r*x));} y=v.y;
Vector zdir(){return Vector( 2*(x*z+r*y), 2*(y*z-r*x),1-2*(x*x+y*y));} z=v.z;
matrix getmatrix(){return matrix(xdir(),ydir(),zdir());} };
//operator matrix(){return getmatrix();} Quaternion(float _r,float _x,float _y,float _z){r=_r;x=_x;y=_y;z=_z;};
}; float angle(){return float(acos(r)*2.0);}
Quaternion operator-(Quaternion q); Vector axis(){Vector a(x,y,z); return a*float(1/sin(angle()/2.0));}
Quaternion operator*(Quaternion a,Quaternion b); Vector xdir(){
Vector operator*(Quaternion q,Vector v); return Vector(1-2*(y*y+z*z), 2*(x*y+r*z), 2*(x*z-r*y));
Vector operator*(Vector v,Quaternion q); }
Quaternion slerp(Quaternion a,Quaternion b,float interp); Vector ydir(){
return Vector( 2*(x*y-r*z),1-2*(x*x+z*z), 2*(y*z+r*x));
#endif }
Vector zdir(){
return Vector( 2*(x*z+r*y), 2*(y*z-r*x),1-2*(x*x+y*y));
}
matrix getmatrix(){return matrix(xdir(),ydir(),zdir());}
//operator matrix(){return getmatrix();}
};
Quaternion operator-(Quaternion q);
Quaternion operator*(Quaternion a,Quaternion b);
Vector operator*(Quaternion q,Vector v);
Vector operator*(Vector v,Quaternion q);
Quaternion slerp(Quaternion a,Quaternion b,float interp);
#endif

691
applications/utilities/surface/surfaceCoarsen/bunnylod/winmain.C
View File

@ -1,155 +1,155 @@
/*
/* * Polygon Reduction Demo by Stan Melax (c) 1998
* Polygon Reduction Demo by Stan Melax (c) 1998 * Permission to use any of this code wherever you want is granted..
* Permission to use any of this code wherever you want is granted.. * Although, please do acknowledge authorship if appropriate.
* Although, please do acknowledge authorship if appropriate. *
* * This module contains the window setup code, mouse input, timing
* This module contains the window setup code, mouse input, timing * routines, and that sort of stuff. The interesting modules
* routines, and that sort of stuff. The interesting modules * to see are bunnygut.cpp and progmesh.cpp.
* to see are bunnygut.cpp and progmesh.cpp. *
* * The windows 95 specific code for this application was taken from
* The windows 95 specific code for this application was taken from
* an example of processing mouse events in an OpenGL program using * an example of processing mouse events in an OpenGL program using
* the Win32 API from the www.opengl.org web site. * the Win32 API from the www.opengl.org web site.
* *
* Under Project->Settings, Link Options, General Category * Under Project->Settings, Link Options, General Category
* Add: * Add:
* Opengl32.lib glu32.lib winmm.lib * Opengl32.lib glu32.lib winmm.lib
* to the Object/Library Modules * to the Object/Library Modules
* *
* You will need have OpenGL libs and include files to compile this * You will need have OpenGL libs and include files to compile this
* Go to the www.opengl.org web site if you need help with this. * Go to the www.opengl.org web site if you need help with this.
*/ */
#include <windows.h> /* must include this before GL/gl.h */ #include <windows.h> /* must include this before GL/gl.h */
#include <GL/gl.h> /* OpenGL header file */ #include <GL/gl.h> /* OpenGL header file */
#include <GL/glu.h> /* OpenGL utilities header file */ #include <GL/glu.h> /* OpenGL utilities header file */
#include <stdio.h> #include <stdio.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/timeb.h> #include <sys/timeb.h>
#include <time.h> #include <time.h>
#include "vector.h"
#include "font.h"
// Functions and Variables from bunny module
extern void InitModel();
extern void RenderModel();
extern Vector model_position; // position of bunny
extern Quaternion model_orientation; // orientation of bunny
// Global Variables
float DeltaT = 0.1f;
float FPS;
int Width = 512;
int Height = 512;
int MouseX = 0;
int MouseY = 0;
Vector MouseVector; // 3D direction mouse points
Vector OldMouseVector;
int MouseState=0; // true iff left button down
float ViewAngle=45.0f;
HDC hDC; /* device context */
HPALETTE hPalette = 0; /* custom palette (if needed) */
void CalcFPSDeltaT(){ #include "vector.h"
static int timeinit=0; #include "font.h"
static int start,start2,current,last;
static int frame=0, frame2=0; // Functions and Variables from bunny module
if(!timeinit){ extern void InitModel();
frame=0; extern void RenderModel();
start=timeGetTime(); extern Vector model_position; // position of bunny
timeinit=1; extern Quaternion model_orientation; // orientation of bunny
}
frame++; // Global Variables
frame2++; float DeltaT = 0.1f;
current=timeGetTime(); // found in winmm.lib float FPS;
double dif=(double)(current-start)/CLOCKS_PER_SEC; int Width = 512;
double rv = (dif)? (double)frame/(double)dif:-1.0; int Height = 512;
if(dif>2.0 && frame >10) { int MouseX = 0;
start = start2; int MouseY = 0;
frame = frame2; Vector MouseVector; // 3D direction mouse points
start2 = timeGetTime(); Vector OldMouseVector;
frame2 = 0; int MouseState=0; // true iff left button down
} float ViewAngle=45.0f;
DeltaT = (float)(current-last)/CLOCKS_PER_SEC;
if(current==last) { HDC hDC; /* device context */
DeltaT = 0.1f/CLOCKS_PER_SEC; // it just cant be 0 HPALETTE hPalette = 0; /* custom palette (if needed) */
}
// if(DeltaT>1.0) DeltaT=1.0;
FPS = (float)rv; void CalcFPSDeltaT(){
last = current; static int timeinit=0;
} static int start,start2,current,last;
static int frame=0, frame2=0;
if(!timeinit){
void ComputeMouseVector(){ frame=0;
OldMouseVector=MouseVector; start=timeGetTime();
float spread = (float)tan(ViewAngle/2*3.14/180); timeinit=1;
float y = spread * ((Height-MouseY)-Height/2.0f) /(Height/2.0f); }
float x = spread * (MouseX-Width/2.0f) /(Height/2.0f); frame++;
Vector v(x ,y,-1); frame2++;
// v=UserOrientation *v; current=timeGetTime(); // found in winmm.lib
v=normalize(v); double dif=(double)(current-start)/CLOCKS_PER_SEC;
MouseVector = v; double rv = (dif)? (double)frame/(double)dif:-1.0;
} if(dif>2.0 && frame >10) {
start = start2;
Quaternion VirtualTrackBall(Vector cop,Vector cor,Vector dir1,Vector dir2) { frame = frame2;
// Implement track ball functionality to spin stuf on the screen start2 = timeGetTime();
// cop center of projection frame2 = 0;
// cor center of rotation }
// dir1 old mouse direction DeltaT = (float)(current-last)/CLOCKS_PER_SEC;
// dir2 new mouse direction if(current==last) {
// pretend there is a sphere around cor. Then find the points DeltaT = 0.1f/CLOCKS_PER_SEC; // it just cant be 0
// where dir1 and dir2 intersect that sphere. Find the }
// rotation that takes the first point to the second. // if(DeltaT>1.0) DeltaT=1.0;
float m; FPS = (float)rv;
// compute plane last = current;
Vector nrml = cor - cop; }
float fudgefactor = 1.0f/(magnitude(nrml) * 0.25f); // since trackball proportional to distance from cop
nrml = normalize(nrml);
float dist = -(nrml^cor); void ComputeMouseVector(){
Vector u= planelineintersection(nrml,dist,cop,cop+dir1); OldMouseVector=MouseVector;
u=u-cor; float spread = (float)tan(ViewAngle/2*3.14/180);
u=u*fudgefactor; float y = spread * ((Height-MouseY)-Height/2.0f) /(Height/2.0f);
m= magnitude(u); float x = spread * (MouseX-Width/2.0f) /(Height/2.0f);
if(m>1) {u=u*1.0f/m;} Vector v(x ,y,-1);
else { // v=UserOrientation *v;
u=u - (nrml * (float)sqrt(1-m*m)); v=normalize(v);
} MouseVector = v;
Vector v= planelineintersection(nrml,dist,cop,cop+dir2); }
v=v-cor;
v=v*fudgefactor; Quaternion VirtualTrackBall(Vector cop,Vector cor,Vector dir1,Vector dir2) {
m= magnitude(v); // Implement track ball functionality to spin stuf on the screen
if(m>1) {v=v*1.0f/m;} // cop center of projection
else { // cor center of rotation
v=v - (nrml * (float)sqrt(1-m*m)); // dir1 old mouse direction
} // dir2 new mouse direction
Vector axis = u*v; // pretend there is a sphere around cor. Then find the points
float angle; // where dir1 and dir2 intersect that sphere. Find the
m=magnitude(axis); // rotation that takes the first point to the second.
if(m>1)m=1; // avoid potential floating point error float m;
Quaternion q(Vector(1.0f,0.0f,0.0f),0.0f); // compute plane
if(m>0 && (angle=(float)asin(m))>3.14/180) { Vector nrml = cor - cop;
axis = normalize(axis); // since trackball proportional to distance from cop
q=Quaternion(axis,angle); float fudgefactor = 1.0f/(magnitude(nrml) * 0.25f);
} nrml = normalize(nrml);
return q; float dist = -(nrml^cor);
} Vector u= planelineintersection(nrml,dist,cop,cop+dir1);
u=u-cor;
void SpinIt(){ u=u*fudgefactor;
// Change the orientation of the bunny according to mouse drag m= magnitude(u);
Quaternion q=VirtualTrackBall(Vector(0,0,0),model_position, if(m>1) {u=u*1.0f/m;}
OldMouseVector,MouseVector); else {
model_orientation=q*model_orientation; u=u - (nrml * (float)sqrt(1-m*m));
} }
Vector v= planelineintersection(nrml,dist,cop,cop+dir2);
void Reshape(int width, int height){ v=v-cor;
// called initially and when the window changes size v=v*fudgefactor;
Width=width; m= magnitude(v);
Height=height; if(m>1) {v=v*1.0f/m;}
else {
v=v - (nrml * (float)sqrt(1-m*m));
}
Vector axis = u*v;
float angle;
m=magnitude(axis);
if(m>1)m=1; // avoid potential floating point error
Quaternion q(Vector(1.0f,0.0f,0.0f),0.0f);
if(m>0 && (angle=(float)asin(m))>3.14/180) {
axis = normalize(axis);
q=Quaternion(axis,angle);
}
return q;
}
void SpinIt(){
// Change the orientation of the bunny according to mouse drag
Quaternion q=VirtualTrackBall(Vector(0,0,0),model_position,
OldMouseVector,MouseVector);
model_orientation=q*model_orientation;
}
void Reshape(int width, int height){
// called initially and when the window changes size
Width=width;
Height=height;
glViewport(0, 0, width, height); glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION); glMatrixMode(GL_PROJECTION);
glLoadIdentity(); glLoadIdentity();
@ -157,111 +157,111 @@ void Reshape(int width, int height){
glMatrixMode(GL_MODELVIEW); glMatrixMode(GL_MODELVIEW);
glLoadIdentity(); glLoadIdentity();
} }
void PrintStats(){ void PrintStats(){
char buf[1024];buf[0]='\0'; char buf[1024];buf[0]='\0';
sprintf(buf,"FPS: %5.2f ",FPS); sprintf(buf,"FPS: %5.2f ",FPS);
PostString(buf,0,-1,0); PostString(buf,0,-1,0);
} }
void Display(){ void Display(){
// main drawing routine - called every frame // main drawing routine - called every frame
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix(); glPushMatrix();
glLoadIdentity(); glLoadIdentity();
// camera at default (zero) position and orientation // camera at default (zero) position and orientation
RenderModel(); RenderModel();
PrintStats(); PrintStats();
glLoadIdentity(); glLoadIdentity();
RenderStrings(); RenderStrings();
glPopMatrix(); glPopMatrix();
glFlush(); glFlush();
SwapBuffers(hDC); /* nop if singlebuffered */ SwapBuffers(hDC); /* nop if singlebuffered */
} }
LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) LONG WINAPI WindowProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{ {
static PAINTSTRUCT ps; static PAINTSTRUCT ps;
static GLboolean left = GL_FALSE; /* left button currently down? */ static GLboolean left = GL_FALSE; /* left button currently down? */
static GLboolean right = GL_FALSE; /* right button currently down? */ static GLboolean right = GL_FALSE; /* right button currently down? */
static int omx, omy, mx, my; static int omx, omy, mx, my;
switch(uMsg) { switch(uMsg) {
case WM_PAINT: case WM_PAINT:
BeginPaint(hWnd, &ps); BeginPaint(hWnd, &ps);
EndPaint(hWnd, &ps); EndPaint(hWnd, &ps);
return 0; return 0;
case WM_SIZE: case WM_SIZE:
Reshape(LOWORD(lParam), HIWORD(lParam)); Reshape(LOWORD(lParam), HIWORD(lParam));
PostMessage(hWnd, WM_PAINT, 0, 0); PostMessage(hWnd, WM_PAINT, 0, 0);
return 0; return 0;
case WM_CHAR: case WM_CHAR:
switch (wParam) { switch (wParam) {
case 27: /* ESC key */ case 27: /* ESC key */
PostQuitMessage(0); PostQuitMessage(0);
break; break;
} }
return 0; return 0;
case WM_LBUTTONDOWN: case WM_LBUTTONDOWN:
/* if we don't set the capture we won't get mouse move /* if we don't set the capture we won't get mouse move
messages when the mouse moves outside the window. */ messages when the mouse moves outside the window. */
SetCapture(hWnd); SetCapture(hWnd);
MouseX = LOWORD(lParam); MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam); MouseY = HIWORD(lParam);
ComputeMouseVector(); ComputeMouseVector();
MouseState = 1; MouseState = 1;
return 0; return 0;
case WM_LBUTTONUP: case WM_LBUTTONUP:
MouseX = LOWORD(lParam); MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam); MouseY = HIWORD(lParam);
if(MouseX & 1 << 15) MouseX -= (1 << 16); if(MouseX & 1 << 15) MouseX -= (1 << 16);
if(MouseY & 1 << 15) MouseY -= (1 << 16); if(MouseY & 1 << 15) MouseY -= (1 << 16);
ComputeMouseVector(); ComputeMouseVector();
if(MouseState) SpinIt(); if(MouseState) SpinIt();
MouseState=0; MouseState=0;
/* remember to release the capture when we are finished. */ /* remember to release the capture when we are finished. */
ReleaseCapture(); ReleaseCapture();
return 0; return 0;
case WM_MOUSEMOVE: case WM_MOUSEMOVE:
MouseX = LOWORD(lParam); MouseX = LOWORD(lParam);
MouseY = HIWORD(lParam); MouseY = HIWORD(lParam);
/* Win32 is pretty braindead about the x, y position that /* Win32 is pretty braindead about the x, y position that
it returns when the mouse is off the left or top edge it returns when the mouse is off the left or top edge
of the window (due to them being unsigned). therefore, of the window (due to them being unsigned). therefore,
roll the Win32's 0..2^16 pointer co-ord range to the roll the Win32's 0..2^16 pointer co-ord range to the
more amenable (and useful) 0..+/-2^15. */ more amenable (and useful) 0..+/-2^15. */
if(MouseX & 1 << 15) MouseX -= (1 << 16); if(MouseX & 1 << 15) MouseX -= (1 << 16);
if(MouseY & 1 << 15) MouseY -= (1 << 16); if(MouseY & 1 << 15) MouseY -= (1 << 16);
ComputeMouseVector(); ComputeMouseVector();
if(MouseState) SpinIt(); if(MouseState) SpinIt();
return 0; return 0;
case WM_PALETTECHANGED: case WM_PALETTECHANGED:
if (hWnd == (HWND)wParam) break; if (hWnd == (HWND)wParam) break;
/* fall through to WM_QUERYNEWPALETTE */ /* fall through to WM_QUERYNEWPALETTE */
case WM_QUERYNEWPALETTE: case WM_QUERYNEWPALETTE:
if (hPalette) { if (hPalette) {
UnrealizeObject(hPalette); UnrealizeObject(hPalette);
SelectPalette(hDC, hPalette, FALSE); SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC); RealizePalette(hDC);
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
case WM_CLOSE: case WM_CLOSE:
PostQuitMessage(0); PostQuitMessage(0);
return 0; return 0;
} }
return DefWindowProc(hWnd, uMsg, wParam, lParam); return DefWindowProc(hWnd, uMsg, wParam, lParam);
} }
HWND CreateOpenGLWindow(char* title) HWND CreateOpenGLWindow(char* title)
{ {
// make a double-buffered, rgba, opengl window // make a double-buffered, rgba, opengl window
int n, pf; int n, pf;
HWND hWnd; HWND hWnd;
WNDCLASS wc; WNDCLASS wc;
@ -271,33 +271,35 @@ HWND CreateOpenGLWindow(char* title)
/* only register the window class once - use hInstance as a flag. */ /* only register the window class once - use hInstance as a flag. */
if (!hInstance) { if (!hInstance) {
hInstance = GetModuleHandle(NULL); hInstance = GetModuleHandle(NULL);
wc.style = CS_OWNDC; wc.style = CS_OWNDC;
wc.lpfnWndProc = (WNDPROC)WindowProc; wc.lpfnWndProc = (WNDPROC)WindowProc;
wc.cbClsExtra = 0; wc.cbClsExtra = 0;
wc.cbWndExtra = 0; wc.cbWndExtra = 0;
wc.hInstance = hInstance; wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW); wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL; wc.hbrBackground = NULL;
wc.lpszMenuName = NULL; wc.lpszMenuName = NULL;
wc.lpszClassName = "OpenGL"; wc.lpszClassName = "OpenGL";
if (!RegisterClass(&wc)) { if (!RegisterClass(&wc)) {
MessageBox(NULL, "RegisterClass() failed: " MessageBox(NULL, "RegisterClass() failed: "
"Cannot register window class.", "Error", MB_OK); "Cannot register window class.",
return NULL; "Error", MB_OK);
} return NULL;
}
} }
hWnd = CreateWindow("OpenGL", title, WS_OVERLAPPEDWINDOW | hWnd = CreateWindow("OpenGL", title, WS_OVERLAPPEDWINDOW |
WS_CLIPSIBLINGS | WS_CLIPCHILDREN, WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
0,0,Width,Height, NULL, NULL, hInstance, NULL); 0,0,Width,Height, NULL, NULL, hInstance, NULL);
if (hWnd == NULL) { if (hWnd == NULL) {
MessageBox(NULL, "CreateWindow() failed: Cannot create a window.", MessageBox(NULL,
"Error", MB_OK); "CreateWindow() failed: Cannot create a window.",
return NULL; "Error", MB_OK);
return NULL;
} }
hDC = GetDC(hWnd); hDC = GetDC(hWnd);
@ -307,134 +309,141 @@ HWND CreateOpenGLWindow(char* title)
memset(&pfd, 0, sizeof(pfd)); memset(&pfd, 0, sizeof(pfd));
pfd.nSize = sizeof(pfd); pfd.nSize = sizeof(pfd);
pfd.nVersion = 1; pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; pfd.dwFlags = PFD_DRAW_TO_WINDOW
| PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA; pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cDepthBits = 32; pfd.cDepthBits = 32;
pfd.cColorBits = 32; pfd.cColorBits = 32;
pf = ChoosePixelFormat(hDC, &pfd); pf = ChoosePixelFormat(hDC, &pfd);
if (pf == 0) { if (pf == 0) {
MessageBox(NULL, "ChoosePixelFormat() failed: " MessageBox(NULL, "ChoosePixelFormat() failed: "
"Cannot find a suitable pixel format.", "Error", MB_OK); "Cannot find a suitable pixel format.",
return 0; "Error", MB_OK);
} return 0;
}
if (SetPixelFormat(hDC, pf, &pfd) == FALSE) { if (SetPixelFormat(hDC, pf, &pfd) == FALSE) {
MessageBox(NULL, "SetPixelFormat() failed: " MessageBox(NULL, "SetPixelFormat() failed: "
"Cannot set format specified.", "Error", MB_OK); "Cannot set format specified.", "Error", MB_OK);
return 0; return 0;
} }
DescribePixelFormat(hDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd); DescribePixelFormat(hDC, pf, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
if (pfd.dwFlags & PFD_NEED_PALETTE || if (pfd.dwFlags & PFD_NEED_PALETTE ||
pfd.iPixelType == PFD_TYPE_COLORINDEX) { pfd.iPixelType == PFD_TYPE_COLORINDEX) {
n = 1 << pfd.cColorBits; n = 1 << pfd.cColorBits;
if (n > 256) n = 256; if (n > 256) n = 256;
lpPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) + lpPal = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
sizeof(PALETTEENTRY) * n); sizeof(PALETTEENTRY) * n);
memset(lpPal, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n); memset(lpPal, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
lpPal->palVersion = 0x300; lpPal->palVersion = 0x300;
lpPal->palNumEntries = n; lpPal->palNumEntries = n;
GetSystemPaletteEntries(hDC, 0, n, &lpPal->palPalEntry[0]); GetSystemPaletteEntries(hDC, 0, n, &lpPal->palPalEntry[0]);
/* if the pixel type is RGBA, then we want to make an RGB ramp,
otherwise (color index) set individual colors. */
if (pfd.iPixelType == PFD_TYPE_RGBA) {
int redMask = (1 << pfd.cRedBits) - 1;
int greenMask = (1 << pfd.cGreenBits) - 1;
int blueMask = (1 << pfd.cBlueBits) - 1;
int i;
/* fill in the entries with an RGB color ramp. */ /* if the pixel type is RGBA, then we want to make an RGB ramp,
for (i = 0; i < n; ++i) { otherwise (color index) set individual colors. */
lpPal->palPalEntry[i].peRed = if (pfd.iPixelType == PFD_TYPE_RGBA) {
(((i >> pfd.cRedShift) & redMask) * 255)/redMask; int redMask = (1 << pfd.cRedBits) - 1;
lpPal->palPalEntry[i].peGreen = int greenMask = (1 << pfd.cGreenBits) - 1;
(((i >> pfd.cGreenShift) & greenMask) * 255)/greenMask; int blueMask = (1 << pfd.cBlueBits) - 1;
lpPal->palPalEntry[i].peBlue = int i;
(((i >> pfd.cBlueShift) & blueMask) * 255)/blueMask;
lpPal->palPalEntry[i].peFlags = 0;
}
} else {
lpPal->palPalEntry[0].peRed = 0;
lpPal->palPalEntry[0].peGreen = 0;
lpPal->palPalEntry[0].peBlue = 0;
lpPal->palPalEntry[0].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[1].peRed = 255;
lpPal->palPalEntry[1].peGreen = 0;
lpPal->palPalEntry[1].peBlue = 0;
lpPal->palPalEntry[1].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[2].peRed = 0;
lpPal->palPalEntry[2].peGreen = 255;
lpPal->palPalEntry[2].peBlue = 0;
lpPal->palPalEntry[2].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[3].peRed = 0;
lpPal->palPalEntry[3].peGreen = 0;
lpPal->palPalEntry[3].peBlue = 255;
lpPal->palPalEntry[3].peFlags = PC_NOCOLLAPSE;
}
hPalette = CreatePalette(lpPal); /* fill in the entries with an RGB color ramp. */
if (hPalette) { for (i = 0; i < n; ++i) {
SelectPalette(hDC, hPalette, FALSE); lpPal->palPalEntry[i].peRed =
RealizePalette(hDC); (((i >> pfd.cRedShift) & redMask) * 255)
} /redMask;
lpPal->palPalEntry[i].peGreen =
(((i >> pfd.cGreenShift) & greenMask) * 255)
/greenMask;
lpPal->palPalEntry[i].peBlue =
(((i >> pfd.cBlueShift) & blueMask) * 255)
/blueMask;
lpPal->palPalEntry[i].peFlags = 0;
}
} else {
lpPal->palPalEntry[0].peRed = 0;
lpPal->palPalEntry[0].peGreen = 0;
lpPal->palPalEntry[0].peBlue = 0;
lpPal->palPalEntry[0].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[1].peRed = 255;
lpPal->palPalEntry[1].peGreen = 0;
lpPal->palPalEntry[1].peBlue = 0;
lpPal->palPalEntry[1].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[2].peRed = 0;
lpPal->palPalEntry[2].peGreen = 255;
lpPal->palPalEntry[2].peBlue = 0;
lpPal->palPalEntry[2].peFlags = PC_NOCOLLAPSE;
lpPal->palPalEntry[3].peRed = 0;
lpPal->palPalEntry[3].peGreen = 0;
lpPal->palPalEntry[3].peBlue = 255;
lpPal->palPalEntry[3].peFlags = PC_NOCOLLAPSE;
}
free(lpPal); hPalette = CreatePalette(lpPal);
if (hPalette) {
SelectPalette(hDC, hPalette, FALSE);
RealizePalette(hDC);
}
free(lpPal);
} }
ReleaseDC(hDC, hWnd); ReleaseDC(hDC, hWnd);
return hWnd; return hWnd;
} }
int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst, int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst,
LPSTR lpszCmdLine, int nCmdShow) LPSTR lpszCmdLine, int nCmdShow)
{ {
HGLRC hRC; /* opengl context */ HGLRC hRC; /* opengl context */
HWND hWnd; /* window */ HWND hWnd; /* window */
MSG msg; /* message */ MSG msg; /* message */
// InitModel() initializes some data structures and // InitModel() initializes some data structures and
// does the progressive mesh polygon reduction algorithm // does the progressive mesh polygon reduction algorithm
// on the model. // on the model.
CalcFPSDeltaT(); // to time the algorithm CalcFPSDeltaT(); // to time the algorithm
InitModel(); InitModel();
CalcFPSDeltaT(); CalcFPSDeltaT();
hWnd = CreateOpenGLWindow("bunnylod by Stan Melax"); hWnd = CreateOpenGLWindow("bunnylod by Stan Melax");
if (hWnd == NULL) exit(1); if (hWnd == NULL) exit(1);
hDC = GetDC(hWnd); hDC = GetDC(hWnd);
hRC = wglCreateContext(hDC); hRC = wglCreateContext(hDC);
wglMakeCurrent(hDC, hRC); wglMakeCurrent(hDC, hRC);
ShowWindow(hWnd, nCmdShow); ShowWindow(hWnd, nCmdShow);
glEnable(GL_DEPTH_TEST); glEnable(GL_DEPTH_TEST);
PostString("Demo by Stan Melax (c)1998",5,-5,20); PostString("Demo by Stan Melax (c)1998",5,-5,20);
PostString("Model by Viewpoint Datalabs (c)1996",5,-4,20); PostString("Model by Viewpoint Datalabs (c)1996",5,-4,20);
char buf[128]; char buf[128];
PostString("Mesh Reduction Algorithm (non-optimized)",1,0,5); PostString("Mesh Reduction Algorithm (non-optimized)",1,0,5);
sprintf(buf,"was executed in %5.3f seconds",DeltaT); sprintf(buf,"was executed in %5.3f seconds",DeltaT);
PostString(buf,2,1,6); PostString(buf,2,1,6);
while (1) { while (1) {
while(PeekMessage(&msg, hWnd, 0, 0, PM_NOREMOVE)) { while(PeekMessage(&msg, hWnd, 0, 0, PM_NOREMOVE)) {
if(GetMessage(&msg, hWnd, 0, 0)) { if(GetMessage(&msg, hWnd, 0, 0)) {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} else { } else {
goto quit; // This 'goto' was in the sample code // This 'goto' was in the sample code
} goto quit;
} }
CalcFPSDeltaT(); }
Display(); CalcFPSDeltaT();
} Display();
}
quit:
quit:
wglMakeCurrent(NULL, NULL); wglMakeCurrent(NULL, NULL);
ReleaseDC(hDC, hWnd); ReleaseDC(hDC, hWnd);
wglDeleteContext(hRC); wglDeleteContext(hRC);

3
applications/utilities/surface/surfaceMeshConvertTesting/surfaceMeshConvertTesting.C
View File

@ -364,7 +364,8 @@ int main(int argc, char *argv[])
Info<< "writing surfMesh again well: " << surfOut.objectPath() << endl; Info<< "writing surfMesh again well: " << surfOut.objectPath()
<< endl;
surfOut.write(); surfOut.write();
// write directly // write directly

3
applications/utilities/surface/surfaceMeshTriangulate/surfaceMeshTriangulate.C
View File

@ -88,7 +88,8 @@ int main(int argc, char *argv[])
// - explicitly named patches only (-patches (at your option) // - explicitly named patches only (-patches (at your option)
// - all patches (default in sequential mode) // - all patches (default in sequential mode)
// - all non-processor patches (default in parallel mode) // - all non-processor patches (default in parallel mode)
// - all non-processor patches (sequential mode, -excludeProcPatches (at your option) // - all non-processor patches (sequential mode, -excludeProcPatches
// (at your option)
// Construct table of patches to include. // Construct table of patches to include.
const polyBoundaryMesh& bMesh = mesh.boundaryMesh(); const polyBoundaryMesh& bMesh = mesh.boundaryMesh();

9
applications/utilities/surface/surfaceSplitNonManifolds/surfaceSplitNonManifolds.C
View File

@ -481,8 +481,8 @@ label sharedFace
} }
// Calculate (inward pointing) normals on edges shared by faces in faceToEdge and // Calculate (inward pointing) normals on edges shared by faces in
// averages them to pointNormals. // faceToEdge and averages them to pointNormals.
void calcPointVecs void calcPointVecs
( (
const triSurface& surf, const triSurface& surf,
@ -696,8 +696,9 @@ int main(int argc, char *argv[])
boolList borderEdge(surf.nEdges(), false); boolList borderEdge(surf.nEdges(), false);
markBorderEdges(debug, surf, borderEdge); markBorderEdges(debug, surf, borderEdge);
// Points on two sides connected to borderEdges are called borderPoints and // Points on two sides connected to borderEdges are called
// will be duplicated. borderPoint contains label of newly introduced vertex. // borderPoints and will be duplicated. borderPoint contains label
// of newly introduced vertex.
labelList borderPoint(surf.nPoints(), -1); labelList borderPoint(surf.nPoints(), -1);
markBorderPoints(debug, surf, borderEdge, borderPoint); markBorderPoints(debug, surf, borderEdge, borderPoint);

7
src/OpenFOAM/db/runTimeSelection/staticMemberFunctions/addToStaticMemberFunctionSelectionTable.H
View File

@ -39,9 +39,10 @@ Description
(baseType,thisType,memberFunction,argNames,lookup,functionPtr) \ (baseType,thisType,memberFunction,argNames,lookup,functionPtr) \
\ \
/* Add the thisType memberFunction to the table, find by lookup name */ \ /* Add the thisType memberFunction to the table, find by lookup name */ \
baseType::add##memberFunction##argNames##StaticMemberFunctionToTable<thisType> \ baseType::add##memberFunction##argNames## \
add_##lookup##_##thisType##memberFunction##argNames##StaticMemberFunctionTo##baseType##Table_\ StaticMemberFunctionToTable<thisType> \
(#lookup, functionPtr) add_##lookup##_##thisType##memberFunction##argNames## \
StaticMemberFunctionTo##baseType##Table_(#lookup, functionPtr)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

24
src/OpenFOAM/global/foamDoc.H
View File

@ -28,20 +28,23 @@ License
OpenFOAM is a free, open source CFD software package produced by OpenFOAM is a free, open source CFD software package produced by
a commercial company, a commercial company,
<a href="http://www.openfoam.com/about">OpenCFD Ltd</a>. <a href="http://www.openfoam.com/about">OpenCFD Ltd</a>.
It has a It has a large user base across most areas of engineering and
large user base across most areas of engineering and science, science, from both commercial and academic organisations.
from both commercial and academic organisations. OpenFOAM has an OpenFOAM has an extensive range of features to solve anything from
extensive range of features to solve anything from complex fluid complex fluid flows involving chemical reactions, turbulence and
flows involving chemical reactions, turbulence and heat transfer, heat transfer, to solid dynamics and electromagnetics.
to solid dynamics and electromagnetics.
<a href="http://www.openfoam.com/features">More ...</a> <a href="http://www.openfoam.com/features">More ...</a>
@section users Our commitment to the users @section users Our commitment to the users
OpenFOAM comes with full commercial support from OpenCFD, including OpenFOAM comes with full commercial support from OpenCFD, including
<a href="http://www.openfoam.com/support/software.php">software support</a>, <a href="http://www.openfoam.com/support/software.php">
<a href="http://www.openfoam.com/support/development.php">contracted developments</a> software support</a>,
and a programme of <a href="http://www.openfoam.com/training/">training courses</a>. <a href="http://www.openfoam.com/support/development.php">
contracted developments</a>
and a programme of
<a href="http://www.openfoam.com/training/">
training courses</a>.
These activities fund the development, maintenance and release of These activities fund the development, maintenance and release of
OpenFOAM to make it an extremely viable commercial open source product. OpenFOAM to make it an extremely viable commercial open source product.
@ -49,7 +52,8 @@ License
OpenCFD is committed to open source software, continually developing and OpenCFD is committed to open source software, continually developing and
maintaining OpenFOAM under the maintaining OpenFOAM under the
<a href="http://www.gnu.org/copyleft/gpl.html">GNU General Public Licence</a>. <a href="http://www.gnu.org/copyleft/gpl.html">
GNU General Public Licence</a>.
OpenFOAM will <strong>always</strong> be free of charge and open source. OpenFOAM will <strong>always</strong> be free of charge and open source.
In addition, we endeavour to support other viable open source initiatives In addition, we endeavour to support other viable open source initiatives
that will benefit science and engineering. that will benefit science and engineering.

3
src/conversion/meshReader/starcd/STARCDMeshReader.C
View File

@ -693,7 +693,8 @@ void Foam::meshReaders::STARCD::readBoundary(const fileName& inputName)
maxId = max(maxId, starRegion); maxId = max(maxId, starRegion);
if (patchType == "BAFF") // should actually be case-insensitive // should actually be case-insensitive
if (patchType == "BAFF")
{ {
nBafflePatches++; nBafflePatches++;
} }

3
src/conversion/meshTables/cellTable.H
View File

@ -140,7 +140,8 @@ public:
//- Return a Map of (id => names) selected by patterns //- Return a Map of (id => names) selected by patterns
Map<word> names(const UList<wordRe>& patterns) const; Map<word> names(const UList<wordRe>& patterns) const;
//- Return a Map of (id => name) for materialType (fluid | solid | shell) //- Return a Map of (id => name) for materialType
// (fluid | solid | shell)
Map<word> selectType(const word& materialType) const; Map<word> selectType(const word& materialType) const;
//- Return a Map of (id => name) for fluids //- Return a Map of (id => name) for fluids

8
src/conversion/polyDualMesh/polyDualMesh.C
View File

@ -1400,8 +1400,8 @@ Foam::polyDualMesh::polyDualMesh
polyMesh polyMesh
( (
mesh, mesh,
xferCopy(pointField()), // to prevent any warnings "points not allocated" xferCopy(pointField()),// to prevent any warnings "points not allocated"
xferCopy(faceList()), // to prevent any warnings "faces not allocated" xferCopy(faceList()), // to prevent any warnings "faces not allocated"
xferCopy(cellList()) xferCopy(cellList())
), ),
cellPoint_ cellPoint_
@ -1445,8 +1445,8 @@ Foam::polyDualMesh::polyDualMesh
polyMesh polyMesh
( (
mesh, mesh,
xferCopy(pointField()), // to prevent any warnings "points not allocated" xferCopy(pointField()),// to prevent any warnings "points not allocated"
xferCopy(faceList()), // to prevent any warnings "faces not allocated" xferCopy(faceList()), // to prevent any warnings "faces not allocated"
xferCopy(cellList()) xferCopy(cellList())
), ),
cellPoint_ cellPoint_

6
src/engine/include/StCorr.H
View File

@ -60,7 +60,11 @@
*sqrt *sqrt
( (
4.0*Vk 4.0*Vk
/(circleFraction*thickness*constant::mathematical::pi) /(
circleFraction
*thickness
*constant::mathematical::pi
)
); );
} }
break; break;

3
src/finiteVolume/cfdTools/general/MRF/MRFZone.C
View File

@ -247,7 +247,8 @@ Foam::MRFZone::MRFZone(const fvMesh& mesh, Istream& is)
WarningIn("MRFZone(const fvMesh&, Istream&)") WarningIn("MRFZone(const fvMesh&, Istream&)")
<< "Ignoring entry 'patches'\n" << "Ignoring entry 'patches'\n"
<< " By default all patches within the rotating region rotate.\n" << " By default all patches within the rotating region rotate.\n"
<< " Optionally supply excluded patches using 'nonRotatingPatches'." << " Optionally supply excluded patches "
<< "using 'nonRotatingPatches'."
<< endl; << endl;
} }

5
src/finiteVolume/cfdTools/general/fieldSources/timeActivatedExplicitSource/TimeActivatedExplicitSourceI.H
View File

@ -208,7 +208,10 @@ inline Foam::labelList& Foam::TimeActivatedExplicitSource<Type>::cells()
template<class Type> template<class Type>
inline Foam::List<typename Foam::TimeActivatedExplicitSource<Type>::fieldNameValuePair>& inline Foam::List
<
typename Foam::TimeActivatedExplicitSource<Type>::fieldNameValuePair
>&
Foam::TimeActivatedExplicitSource<Type>::fieldData() Foam::TimeActivatedExplicitSource<Type>::fieldData()
{ {
return fieldData_; return fieldData_;

5
src/lagrangian/dieselSpray/injector/commonRailInjector/commonRailInjector.C
View File

@ -381,7 +381,10 @@ Foam::scalar Foam::commonRailInjector::Cd
} }
Foam::scalar Foam::commonRailInjector::fractionOfInjection(const scalar time) const Foam::scalar Foam::commonRailInjector::fractionOfInjection
(
const scalar time
) const
{ {
return integrateTable(massFlowRateProfile_, time)/mass_; return integrateTable(massFlowRateProfile_, time)/mass_;
} }

19
src/lagrangian/dieselSpray/injector/swirlInjector/swirlInjector.H
View File

@ -103,13 +103,20 @@ private:
//- Return the fraction of the total injected liquid //- Return the fraction of the total injected liquid
scalar fractionOfInjection(const scalar time) const; scalar fractionOfInjection(const scalar time) const;
/*
//- Return the average injection velocity
scalar averageInjectionVelocityTime(const scalar liquidDensity) const;
//- Return the instantaneous injection velocity // //- Return the average injection velocity
scalar injectionVelocity(const scalar, const scalar liquidDensity) const; // scalar averageInjectionVelocityTime
*/ // (
// const scalar liquidDensity
// ) const;
// //- Return the instantaneous injection velocity
// scalar injectionVelocity
// (
// const scalar,
// const scalar liquidDensity
// ) const;
public: public:

3
src/lagrangian/dieselSpray/parcel/parcel.C
View File

@ -465,7 +465,8 @@ void Foam::parcel::updateParcelProperties
while ((n < sDB.evaporation().nEvapIter()) && (m() > VSMALL)) while ((n < sDB.evaporation().nEvapIter()) && (m() > VSMALL))
{ {
n++; n++;
// new characteristic times does not need to be calculated the first time // new characteristic times does not need to be calculated the
// first time
if (n > 1) if (n > 1)
{ {
newDensity = fuels.rho(pg, Tnew, X()); newDensity = fuels.rho(pg, Tnew, X());

30
src/lagrangian/dieselSpray/parcel/setRelaxationTimes.C
View File

@ -190,7 +190,8 @@ void Foam::parcel::setRelaxationTimes
{ {
if (!boiling) if (!boiling)
{ {
// for saturation evaporation, only use 99.99% for numerical robustness // for saturation evaporation, only use 99.99% for
// numerical robustness
scalar dm = max(SMALL, 0.9999*msat[i] - mfg[i]); scalar dm = max(SMALL, 0.9999*msat[i] - mfg[i]);
tauEvaporation[i] = sDB.evaporation().relaxationTime tauEvaporation[i] = sDB.evaporation().relaxationTime
@ -213,16 +214,23 @@ void Foam::parcel::setRelaxationTimes
scalar Nusselt = scalar Nusselt =
sDB.heatTransfer().Nu(Reynolds, Prandtl); sDB.heatTransfer().Nu(Reynolds, Prandtl);
// calculating the boiling temperature of the liquid at ambient pressure // calculating the boiling temperature of the liquid
// at ambient pressure
scalar tBoilingSurface = Td; scalar tBoilingSurface = Td;
label Niter = 0; label Niter = 0;
scalar deltaT = 10.0; scalar deltaT = 10.0;
scalar dp0 = fuels.properties()[i].pv(pressure, tBoilingSurface) - pressure; scalar dp0 =
fuels.properties()[i].pv(pressure, tBoilingSurface)
- pressure;
while ((Niter < 200) && (mag(deltaT) > 1.0e-3)) while ((Niter < 200) && (mag(deltaT) > 1.0e-3))
{ {
Niter++; Niter++;
scalar pBoil = fuels.properties()[i].pv(pressure, tBoilingSurface); scalar pBoil = fuels.properties()[i].pv
(
pressure,
tBoilingSurface
);
scalar dp = pBoil - pressure; scalar dp = pBoil - pressure;
if ( (dp > 0.0) && (dp0 > 0.0) ) if ( (dp > 0.0) && (dp0 > 0.0) )
{ {
@ -255,11 +263,19 @@ void Foam::parcel::setRelaxationTimes
forAll(sDB.gasProperties(), k) forAll(sDB.gasProperties(), k)
{ {
vapourSurfaceEnthalpy += sDB.composition().Y()[k][celli]*sDB.gasProperties()[k].H(tBoilingSurface); vapourSurfaceEnthalpy +=
vapourFarEnthalpy += sDB.composition().Y()[k][celli]*sDB.gasProperties()[k].H(temperature); sDB.composition().Y()[k][celli]
*sDB.gasProperties()[k].H(tBoilingSurface);
vapourFarEnthalpy +=
sDB.composition().Y()[k][celli]
*sDB.gasProperties()[k].H(temperature);
} }
scalar kLiquid = fuels.properties()[i].K(pressure, 0.5*(tBoilingSurface+T())); scalar kLiquid = fuels.properties()[i].K
(
pressure,
0.5*(tBoilingSurface+T())
);
tauBoiling[i] = sDB.evaporation().boilingTime tauBoiling[i] = sDB.evaporation().boilingTime
( (

6
src/lagrangian/dieselSpray/spraySubModels/collisionModel/ORourke/sameCell.H
View File

@ -48,7 +48,11 @@ if (( xx > collProb) && (mMin > VSMALL) && (mMax > VSMALL)) {
// use mass-averaged temperature to calculate We number // use mass-averaged temperature to calculate We number
scalar averageTemp = (pMax().T()*mMax + pMin().T()*mMin)/mTot; scalar averageTemp = (pMax().T()*mMax + pMin().T()*mMin)/mTot;
// and mass averaged mole fractions ... // and mass averaged mole fractions ...
scalarField Xav((pMax().m()*pMax().X()+pMin().m()*pMin().X())/(pMax().m() + pMin().m())); scalarField Xav
(
(pMax().m()*pMax().X()+pMin().m()*pMin().X())
/(pMax().m() + pMin().m())
);
scalar sigma = spray_.fuels().sigma(pc, averageTemp, Xav); scalar sigma = spray_.fuels().sigma(pc, averageTemp, Xav);
sigma = max(1.0e-6, sigma); sigma = max(1.0e-6, sigma);
scalar rho = spray_.fuels().rho(pc, averageTemp, Xav); scalar rho = spray_.fuels().rho(pc, averageTemp, Xav);

4
src/lagrangian/dieselSpray/spraySubModels/collisionModel/trajectoryModel/trajectoryCM.H
View File

@ -129,7 +129,9 @@ if (vAlign > 0)
pMax().d() = pMax().d() =
pow pow
( (
6.0*newMaxMass/(rhoMax*constant::mathematical::pi*nMax), 6.0
*newMaxMass
/(rhoMax*constant::mathematical::pi*nMax),
1.0/3.0 1.0/3.0
); );

12
src/lagrangian/dieselSpray/spraySubModels/evaporationModel/RutlandFlashBoil/RutlandFlashBoil.C
View File

@ -253,7 +253,9 @@ Foam::scalar Foam::RutlandFlashBoil::boilingTime
} }
scalar Gf = scalar Gf =
4.0*alfaS*dTLB*constant::mathematical::pi*sqr(diameter/2.0)/heatOfVapour; 4.0*alfaS*dTLB
*constant::mathematical::pi*sqr(diameter/2.0)
/heatOfVapour;
// calculation of the heat transfer vapourization at superheated // calculation of the heat transfer vapourization at superheated
// conditions (temperature>tBoilingSurface) // conditions (temperature>tBoilingSurface)
@ -265,7 +267,8 @@ Foam::scalar Foam::RutlandFlashBoil::boilingTime
mag((vapourFarEnthalpy-vapourSurfaceEnthalpy)/heatOfVapour); mag((vapourFarEnthalpy-vapourSurfaceEnthalpy)/heatOfVapour);
// 2.0? or 1.0? try 1! // 2.0? or 1.0? try 1!
scalar B = 1.0*constant::mathematical::pi*kappa/cpGas*diameter*NusseltCorr; scalar B =
1.0*constant::mathematical::pi*kappa/cpGas*diameter*NusseltCorr;
scalar nPos = B*log(1.0 + A)/Gf + 1.0; scalar nPos = B*log(1.0 + A)/Gf + 1.0;
scalar nNeg = (1.0/A)*(exp(Gf/B) - 1.0 - A) + 1.0; scalar nNeg = (1.0/A)*(exp(Gf/B) - 1.0 - A) + 1.0;
@ -338,7 +341,10 @@ Foam::scalar Foam::RutlandFlashBoil::boilingTime
} }
} }
time = (constant::mathematical::pi*pow3(diameter)/6.0)*liquidDensity/(G + Gf); time =
(constant::mathematical::pi*pow3(diameter)/6.0)
*liquidDensity
/(G + Gf);
time = max(VSMALL, time); time = max(VSMALL, time);
} }

9
src/lagrangian/dieselSpray/spraySubModels/injectorModel/Chomiak/Chomiak.C
View File

@ -77,7 +77,11 @@ Foam::ChomiakInjector::ChomiakInjector
// correct velocityProfile // correct velocityProfile
forAll(sm.injectors(), i) forAll(sm.injectors(), i)
{ {
sm.injectors()[i].properties()->correctProfiles(sm.fuels(), referencePressure); sm.injectors()[i].properties()->correctProfiles
(
sm.fuels(),
referencePressure
);
} }
} }
@ -129,7 +133,8 @@ Foam::vector Foam::ChomiakInjector::direction
scalar reduce = 0.01; scalar reduce = 0.01;
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0-2.0*reduce)*0.5*sm_.angleOfWedge()/constant::mathematical::pi; beta *=
(1.0-2.0*reduce)*0.5*sm_.angleOfWedge()/constant::mathematical::pi;
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =

5
src/lagrangian/dieselSpray/spraySubModels/injectorModel/blobsSwirl/blobsSwirlInjector.C
View File

@ -150,7 +150,10 @@ Foam::vector Foam::blobsSwirlInjector::direction
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi); beta *=
(1.0 - 2.0*reduce)
*sm_.angleOfWedge()
/(constant::mathematical::twoPi);
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =
alpha alpha

3
src/lagrangian/dieselSpray/spraySubModels/injectorModel/blobsSwirl/blobsSwirlInjector.H
View File

@ -30,7 +30,8 @@ Description
Accurate description in: Accurate description in:
@verbatim @verbatim
Z. Han, S. Parrish, P.V. Farrell, R.D. Reitz Z. Han, S. Parrish, P.V. Farrell, R.D. Reitz
"Modeling Atomization Processes Of Pressure Swirl Hollow-Cone Fuel Sprays" "Modeling Atomization Processes Of Pressure
Swirl Hollow-Cone Fuel Sprays"
Atomization and Sprays, vol. 7, pp. 663-684, 1997 Atomization and Sprays, vol. 7, pp. 663-684, 1997
@endverbatim @endverbatim
and and

8
src/lagrangian/dieselSpray/spraySubModels/injectorModel/constant/constInjector.C
View File

@ -129,7 +129,8 @@ Foam::vector Foam::constInjector::direction
v (alpha) v (alpha)
*/ */
scalar angle = rndGen_.scalar01()*sprayAngle_[n]*constant::mathematical::pi/360.0; scalar angle =
rndGen_.scalar01()*sprayAngle_[n]*constant::mathematical::pi/360.0;
scalar alpha = sin(angle); scalar alpha = sin(angle);
scalar dcorr = cos(angle); scalar dcorr = cos(angle);
@ -143,7 +144,10 @@ Foam::vector Foam::constInjector::direction
scalar reduce = 0.01; scalar reduce = 0.01;
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*0.5*sm_.angleOfWedge()/constant::mathematical::pi; beta *=
(1.0 - 2.0*reduce)
*0.5*sm_.angleOfWedge()
/constant::mathematical::pi;
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =

5
src/lagrangian/dieselSpray/spraySubModels/injectorModel/definedHollowCone/definedHollowCone.C
View File

@ -172,7 +172,10 @@ Foam::vector Foam::definedHollowConeInjector::direction
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi); beta *=
(1.0 - 2.0*reduce)
*sm_.angleOfWedge()
/(constant::mathematical::twoPi);
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =
alpha alpha

10
src/lagrangian/dieselSpray/spraySubModels/injectorModel/definedPressureSwirl/definedPressureSwirl.C
View File

@ -223,7 +223,10 @@ Foam::vector Foam::definedPressureSwirlInjector::direction
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi); beta *=
(1.0 - 2.0*reduce)
*sm_.angleOfWedge()
/(constant::mathematical::twoPi);
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =
alpha alpha
@ -261,7 +264,10 @@ Foam::scalar Foam::definedPressureSwirlInjector::velocity
} }
Foam::scalar Foam::definedPressureSwirlInjector::averageVelocity(const label i) const Foam::scalar Foam::definedPressureSwirlInjector::averageVelocity
(
const label i
) const
{ {
const injectorType& it = sm_.injectors()[i].properties(); const injectorType& it = sm_.injectors()[i].properties();

5
src/lagrangian/dieselSpray/spraySubModels/injectorModel/hollowCone/hollowCone.C
View File

@ -139,7 +139,10 @@ Foam::vector Foam::hollowConeInjector::direction
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi); beta *=
(1.0 - 2.0*reduce)
*sm_.angleOfWedge()
/(constant::mathematical::twoPi);
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =
alpha alpha

5
src/lagrangian/dieselSpray/spraySubModels/injectorModel/pressureSwirl/pressureSwirlInjector.C
View File

@ -145,7 +145,10 @@ Foam::vector Foam::pressureSwirlInjector::direction
// correct beta if this is a 2D run // correct beta if this is a 2D run
// map it onto the 'angleOfWedge' // map it onto the 'angleOfWedge'
beta *= (1.0 - 2.0*reduce)*sm_.angleOfWedge()/(constant::mathematical::twoPi); beta *=
(1.0 - 2.0*reduce)
*sm_.angleOfWedge()
/(constant::mathematical::twoPi);
beta += reduce*sm_.angleOfWedge(); beta += reduce*sm_.angleOfWedge();
normal = normal =
alpha alpha

4
src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/DevolatilisationModel/DevolatilisationModel.C
View File

@ -76,7 +76,8 @@ const Foam::dictionary& Foam::DevolatilisationModel<CloudType>::dict() const
template<class CloudType> template<class CloudType>
const Foam::dictionary& Foam::DevolatilisationModel<CloudType>::coeffDict() const const Foam::dictionary&
Foam::DevolatilisationModel<CloudType>::coeffDict() const
{ {
return coeffDict_; return coeffDict_;
} }
@ -87,4 +88,3 @@ const Foam::dictionary& Foam::DevolatilisationModel<CloudType>::coeffDict() cons
#include "DevolatilisationModelNew.C" #include "DevolatilisationModelNew.C"
// ************************************************************************* // // ************************************************************************* //

6
src/lagrangian/intermediate/submodels/ReactingMultiphase/InjectionModel/ReactingMultiphaseLookupTableInjection/reactingMultiphaseParcelInjectionDataIOList.C
View File

@ -29,7 +29,11 @@ License
namespace Foam namespace Foam
{ {
defineTemplateTypeNameAndDebug(IOList<reactingMultiphaseParcelInjectionData>, 0); defineTemplateTypeNameAndDebug
(
IOList<reactingMultiphaseParcelInjectionData>,
0
);
} }

5
src/lagrangian/molecularDynamics/potential/energyScalingFunction/basic/energyScalingFunction.H
View File

@ -132,7 +132,10 @@ public:
} }
//- Read energyScalingFunction dictionary //- Read energyScalingFunction dictionary
virtual bool read(const dictionary& energyScalingFunctionProperties) = 0; virtual bool read
(
const dictionary& energyScalingFunctionProperties
) = 0;
}; };

6
src/lagrangian/molecularDynamics/potential/pairPotential/derived/maitlandSmith/maitlandSmith.H
View File

@ -31,7 +31,8 @@ Description
@verbatim @verbatim
@ARTICLE{MA_Maitland_Smith, @ARTICLE{MA_Maitland_Smith,
author = {{Maitland}, G.~C. and {Smith}, E.~B.}, author = {{Maitland}, G.~C. and {Smith}, E.~B.},
title = {A simplified representation of intermolecular potential energy}, title = {A simplified representation of
intermolecular potential energy},
journal = {Chemical Physics Letters}, journal = {Chemical Physics Letters},
year = 1973, year = 1973,
month = oct, month = oct,
@ -45,7 +46,8 @@ Description
Parameters for other monoatomics from: Parameters for other monoatomics from:
@verbatim @verbatim
@BOOK{MD_Maitland_Rigby_Smith_Wakeham, @BOOK{MD_Maitland_Rigby_Smith_Wakeham,
AUTHOR = {Geoffrey C. Maitland and Maurice Rigby and E. Brian Smith and William A. Wakeham}, AUTHOR = {Geoffrey C. Maitland and Maurice Rigby and
E. Brian Smith and William A. Wakeham},
TITLE = {Intermolecular Forces: Their Origin and Determination}, TITLE = {Intermolecular Forces: Their Origin and Determination},
PUBLISHER = {Oxford University Press}, PUBLISHER = {Oxford University Press},
YEAR = {1981} YEAR = {1981}

3
src/lagrangian/molecularDynamics/potential/tetherPotential/tetherPotentialList/tetherPotentialList.C
View File

@ -50,7 +50,8 @@ void Foam::tetherPotentialList::readTetherPotentialDict
if (tetherId == -1) if (tetherId == -1)
{ {
FatalErrorIn("tetherPotentialList::readTetherPotentialDict") FatalErrorIn("tetherPotentialList::readTetherPotentialDict")
<< nl << "No matching entry found in siteIdList for tether name " << nl
<< "No matching entry found in siteIdList for tether name "
<< tetherPotentialName << tetherPotentialName
<< abort(FatalError); << abort(FatalError);
} }

5
src/meshTools/triSurface/booleanOps/booleanSurface/booleanSurface.C
View File

@ -590,7 +590,10 @@ Foam::booleanSurface::booleanSurface
// Copy points from subSurf1 and remember the labels of the ones in // Copy points from subSurf1 and remember the labels of the ones in
// the intersection // the intersection
labelList intersectionLabels(cutSurf1.nPoints() - cutSurf1.nSurfacePoints()); labelList intersectionLabels
(
cutSurf1.nPoints() - cutSurf1.nSurfacePoints()
);
label combinedPointI = 0; label combinedPointI = 0;

26
src/meshTools/triSurface/triSurfaceTools/geompack/geompack.C
View File

@ -250,11 +250,11 @@ void d2vec_part_quick_a ( int n, double a[], int *l, int *r )
return; return;
} }
//******************************************************************************* //******************************************************************************
void d2vec_permute ( int n, double a[], int p[] ) void d2vec_permute ( int n, double a[], int p[] )
//******************************************************************************* //******************************************************************************
// //
// Purpose: // Purpose:
// //
@ -383,7 +383,8 @@ int *d2vec_sort_heap_index_a ( int n, double a[] )
// //
// Purpose: // Purpose:
// //
// D2VEC_SORT_HEAP_INDEX_A does an indexed heap ascending sort of an R2 vector. // D2VEC_SORT_HEAP_INDEX_A does an indexed heap ascending sort of
// an R2 vector.
// //
// Discussion: // Discussion:
// //
@ -864,7 +865,8 @@ void dmat_uniform ( int m, int n, double b, double c, int *seed, double r[] )
// //
// Purpose: // Purpose:
// //
// DMAT_UNIFORM fills a double precision array with scaled pseudorandom values. // DMAT_UNIFORM fills a double precision array with scaled
// pseudorandom values.
// //
// Discussion: // Discussion:
// //
@ -983,8 +985,9 @@ int dtris2 ( int point_num, double point_xy[], int *tri_num,
// //
// Input, int POINT_NUM, the number of vertices. // Input, int POINT_NUM, the number of vertices.
// //
// Input/output, double POINT_XY[POINT_NUM*2], the coordinates of the vertices. // Input/output, double POINT_XY[POINT_NUM*2], the coordinates of
// On output, the vertices have been sorted into dictionary order. // the vertices. On output, the vertices have been sorted into
// dictionary order.
// //
// Output, int *TRI_NUM, the number of triangles in the triangulation; // Output, int *TRI_NUM, the number of triangles in the triangulation;
// TRI_NUM is equal to 2*POINT_NUM - NB - 2, where NB is the number // TRI_NUM is equal to 2*POINT_NUM - NB - 2, where NB is the number
@ -1703,11 +1706,11 @@ int i_sign ( int i )
} }
} }
//******************************************************************************* //******************************************************************************
int i_wrap ( int ival, int ilo, int ihi ) int i_wrap ( int ival, int ilo, int ihi )
//******************************************************************************* //******************************************************************************
// //
// Purpose: // Purpose:
// //
@ -3008,7 +3011,8 @@ double *triangle_circumcenter_2d ( double t[] )
// //
// Input, double T[2*3], the triangle vertices. // Input, double T[2*3], the triangle vertices.
// //
// Output, double *X, *Y, the coordinates of the circumcenter of the triangle. // Output, double *X, *Y, the coordinates of the circumcenter of
// the triangle.
// //
{ {
# define DIM_NUM 2 # define DIM_NUM 2
@ -3043,8 +3047,8 @@ double *triangle_circumcenter_2d ( double t[] )
} }
//****************************************************************************** //******************************************************************************
bool triangulation_plot_eps ( const char *file_out_name, int g_num, double g_xy[], bool triangulation_plot_eps ( const char *file_out_name, int g_num,
int tri_num, int nod_tri[] ) double g_xy[], int tri_num, int nod_tri[] )
//****************************************************************************** //******************************************************************************
// //

9
src/meshTools/triSurface/triSurfaceTools/geompack/geompack.H
View File

@ -30,8 +30,8 @@ void ivec_heap_d ( int n, int a[] );
int *ivec_indicator ( int n ); int *ivec_indicator ( int n );
void ivec_sort_heap_a ( int n, int a[] ); void ivec_sort_heap_a ( int n, int a[] );
void ivec_sorted_unique ( int n, int a[], int *nuniq ); void ivec_sorted_unique ( int n, int a[], int *nuniq );
int lrline ( double xu, double yu, double xv1, double yv1, double xv2, double yv2, int lrline ( double xu, double yu, double xv1, double yv1, double xv2,
double dv ); double yv2, double dv );
bool perm_check ( int n, int p[] ); bool perm_check ( int n, int p[] );
void perm_inv ( int n, int p[] ); void perm_inv ( int n, int p[] );
int *points_delaunay_naive_2d ( int n, double p[], int *ntri ); int *points_delaunay_naive_2d ( int n, double p[], int *ntri );
@ -42,10 +42,9 @@ int swapec ( int i, int *top, int *btri, int *bedg, int point_num,
void timestamp ( void ); void timestamp ( void );
char *timestring ( void ); char *timestring ( void );
double *triangle_circumcenter_2d ( double t[] ); double *triangle_circumcenter_2d ( double t[] );
bool triangulation_plot_eps ( const char *file_out_name, int g_num, double g_xy[], bool triangulation_plot_eps ( const char *file_out_name,
int tri_num, int nod_tri[] ); int g_num, double g_xy[], int tri_num, int nod_tri[] );
void triangulation_print ( int point_num, double xc[], int tri_num, void triangulation_print ( int point_num, double xc[], int tri_num,
int tri_vert[], int tri_nabe[] ); int tri_vert[], int tri_nabe[] );
void vbedg ( double x, double y, int point_num, double point_xy[], int tri_num, void vbedg ( double x, double y, int point_num, double point_xy[], int tri_num,
int tri_vert[], int tri_nabe[], int *ltri, int *ledg, int *rtri, int *redg ); int tri_vert[], int tri_nabe[], int *ltri, int *ledg, int *rtri, int *redg );

6
src/postProcessing/functionObjects/field/surfaceInterpolateFields/surfaceInterpolateFieldsFunctionObject.C
View File

@ -29,7 +29,11 @@ License
namespace Foam namespace Foam
{ {
defineNamedTemplateTypeNameAndDebug(surfaceInterpolateFieldsFunctionObject, 0); defineNamedTemplateTypeNameAndDebug
(
surfaceInterpolateFieldsFunctionObject,
0
);
addToRunTimeSelectionTable addToRunTimeSelectionTable
( (

4
src/postProcessing/functionObjects/field/surfaceInterpolateFields/surfaceInterpolateFieldsFunctionObject.H
View File

@ -25,8 +25,8 @@ Typedef
Foam::surfaceInterpolateFieldsFunctionObject Foam::surfaceInterpolateFieldsFunctionObject
Description Description
FunctionObject wrapper around surfaceInterpolateFields to allow them to be created via FunctionObject wrapper around surfaceInterpolateFields to allow
the functions entry within controlDict. them to be created via the functions entry within controlDict.
SourceFiles SourceFiles
surfaceInterpolateFieldsFunctionObject.C surfaceInterpolateFieldsFunctionObject.C

4
src/thermophysicalModels/pdfs/RosinRammler/RosinRammler.H
View File

@ -28,7 +28,9 @@ Description
Rosin-Rammler pdf Rosin-Rammler pdf
@f[ @f[
cumulative pdf = (1.0 - exp( -((x - d0)/d)^n ) / (1.0 - exp( -((d1 - d0)/d)^n ) cumulative pdf =
(1.0 - exp( -(( x - d0)/d)^n )
/ (1.0 - exp( -((d1 - d0)/d)^n )
@f] @f]

166
tutorials/incompressible/simpleFoam/windTurbineTerrain/constant/polyMesh/blockMeshDict
View File

@ -1,83 +1,83 @@
/*--------------------------------*- C++ -*----------------------------------*\ /*--------------------------------*- C++ -*----------------------------------*\
| ========= | | | ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox | | \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: 1.6 | | \\ / O peration | Version: 1.6 |
| \\ / A nd | Web: www.OpenFOAM.com | | \\ / A nd | Web: www.OpenFOAM.com |
| \\/ M anipulation | | | \\/ M anipulation | |
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
FoamFile FoamFile
{ {
version 2.0; version 2.0;
format ascii; format ascii;
class dictionary; class dictionary;
object blockMeshDict; object blockMeshDict;
} }
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
convertToMeters 1; convertToMeters 1;
vertices vertices
( (
/* /*
( 581761 4.78575e+06 1000) ( 581761 4.78575e+06 1000)
( 581861 4.78575e+06 1000) ( 581861 4.78575e+06 1000)
( 581861 4.78585e+06 1000) ( 581861 4.78585e+06 1000)
( 581761 4.78585e+06 1000) ( 581761 4.78585e+06 1000)
( 581761 4.78575e+06 1100) ( 581761 4.78575e+06 1100)
( 581861 4.78575e+06 1100) ( 581861 4.78575e+06 1100)
( 581861 4.78585e+06 1100) ( 581861 4.78585e+06 1100)
( 581761 4.78585e+06 1100) ( 581761 4.78585e+06 1100)
*/ */
( 581321 4.78537e+06 930) ( 581321 4.78537e+06 930)
( 582290 4.78537e+06 930) ( 582290 4.78537e+06 930)
( 582290 4.78624e+06 930) ( 582290 4.78624e+06 930)
( 581321 4.78624e+06 930) ( 581321 4.78624e+06 930)
( 581321 4.78537e+06 1500) ( 581321 4.78537e+06 1500)
( 582290 4.78537e+06 1500) ( 582290 4.78537e+06 1500)
( 582290 4.78624e+06 1500) ( 582290 4.78624e+06 1500)
( 581321 4.78624e+06 1500) ( 581321 4.78624e+06 1500)
); );
blocks blocks
( (
hex (0 1 2 3 4 5 6 7) (30 30 20) simpleGrading (1 1 1) hex (0 1 2 3 4 5 6 7) (30 30 20) simpleGrading (1 1 1)
); );
edges edges
( (
); );
patches patches
( (
patch outlet patch outlet
( (
(2 6 5 1) (2 6 5 1)
) )
patch sides patch sides
( (
(1 5 4 0) (1 5 4 0)
(3 7 6 2) (3 7 6 2)
) )
patch inlet patch inlet
( (
(0 4 7 3) (0 4 7 3)
) )
wall ground wall ground
( (
(0 3 2 1) (0 3 2 1)
) )
patch top patch top
( (
(4 5 6 7) (4 5 6 7)
) )
); );
mergePatchPairs mergePatchPairs
( (
); );
// ************************************************************************* // // ************************************************************************* //

21146
tutorials/mesh/moveDynamicMesh/SnakeRiverCanyon/constant/triSurface/AcrossCyn.XYZ
View File

File diff suppressed because it is too large Load Diff

3
tutorials/multiphase/interFoam/MRFInterFoam/MRFInterFoam/pEqn.H
View File

@ -14,7 +14,8 @@
phi = phiU + phi = phiU +
( (
fvc::interpolate(interface.sigmaK())*fvc::snGrad(alpha1)*mesh.magSf() fvc::interpolate(interface.sigmaK())
*fvc::snGrad(alpha1)*mesh.magSf()
+ fvc::interpolate(rho)*(g & mesh.Sf()) + fvc::interpolate(rho)*(g & mesh.Sf())
)*rUAf; )*rUAf;
adjustPhi(phi, U, p); adjustPhi(phi, U, p);