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

Merge branch 'master' of ssh://noisy/home/noisy3/OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
Henry
2011-04-28 21:14:18 +01:00
parent 24adaa0e1d eaa2a9f1b5
commit e3eae71014
129 changed files with 6693 additions and 2629 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/OpenFOAM/Make/files
View File

@ -571,6 +571,10 @@ interpolations = interpolations
interpolation = $(interpolations)/interpolation
$(interpolations)/patchToPatchInterpolation/PatchToPatchInterpolationName.C
$(interpolations)/interpolationTable/tableReaders/tableReaders.C
$(interpolations)/interpolationTable/tableReaders/openFoam/openFoamTableReaders.C
$(interpolations)/interpolationTable/tableReaders/csv/csvTableReaders.C
algorithms/MeshWave/MeshWaveName.C
algorithms/MeshWave/FaceCellWaveName.C

32
src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,6 +25,7 @@ License
#include "interpolationTable.H"
#include "IFstream.H"
#include "openFoamTableReader.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
@ -38,19 +39,19 @@ void Foam::interpolationTable<Type>::readTable()
fName.expand();
// Read data from file
IFstream(fName)() >> *this;
// Check that the data are okay
check();
reader_()(fName, *this);
if (this->empty())
{
FatalErrorIn
(
"Foam::interpolationTable<Type>::readTable()"
) << "table is empty" << nl
) << "table read from " << fName << " is empty" << nl
<< exit(FatalError);
}
// Check that the data are okay
check();
}
@ -61,7 +62,8 @@ Foam::interpolationTable<Type>::interpolationTable()
:
List<Tuple2<scalar, Type> >(),
boundsHandling_(interpolationTable::WARN),
fileName_("fileNameIsUndefined")
fileName_("fileNameIsUndefined"),
reader_(NULL)
{}
@ -75,7 +77,8 @@ Foam::interpolationTable<Type>::interpolationTable
:
List<Tuple2<scalar, Type> >(values),
boundsHandling_(bounds),
fileName_(fName)
fileName_(fName),
reader_(NULL)
{}
@ -84,7 +87,8 @@ Foam::interpolationTable<Type>::interpolationTable(const fileName& fName)
:
List<Tuple2<scalar, Type> >(),
boundsHandling_(interpolationTable::WARN),
fileName_(fName)
fileName_(fName),
reader_(new openFoamTableReader<Type>())
{
readTable();
}
@ -95,7 +99,8 @@ Foam::interpolationTable<Type>::interpolationTable(const dictionary& dict)
:
List<Tuple2<scalar, Type> >(),
boundsHandling_(wordToBoundsHandling(dict.lookup("outOfBounds"))),
fileName_(dict.lookup("fileName"))
fileName_(dict.lookup("fileName")),
reader_(tableReader<Type>::New(dict))
{
readTable();
}
@ -109,7 +114,8 @@ Foam::interpolationTable<Type>::interpolationTable
:
List<Tuple2<scalar, Type> >(interpTable),
boundsHandling_(interpTable.boundsHandling_),
fileName_(interpTable.fileName_)
fileName_(interpTable.fileName_),
reader_(interpTable.reader_) // note: steals reader. Used in write().
{}
@ -233,6 +239,10 @@ void Foam::interpolationTable<Type>::write(Ostream& os) const
<< fileName_ << token::END_STATEMENT << nl;
os.writeKeyword("outOfBounds")
<< boundsHandlingToWord(boundsHandling_) << token::END_STATEMENT << nl;
if (reader_.valid())
{
reader_->write(os);
}
}

18
src/OpenFOAM/interpolations/interpolationTable/interpolationTable.H
View File

@ -34,6 +34,19 @@ Description
If \a REPEAT is chosen for the out-of-bounds handling, the final time
value is treated as being equivalent to time=0 for the following periods.
The construct from dictionary reads a filename from a dictionary and
has an optional readerType. Default is to read OpenFOAM format. The only
other format is csv (comma separated values):
Read csv format:
readerType csv;
fileName "$FOAM_CASE/constant/p0vsTime.csv";
hasHeaderLine true; // skip first line
timeColumn 0; // time is in column 0
valueColumns (1); // value starts in column 1
Note
- Accessing an empty list results in an error.
- Accessing a list with a single element always returns the same value.
@ -49,6 +62,9 @@ SourceFiles
#include "List.H"
#include "Tuple2.H"
#include "tableReader.H"
#include "autoPtr.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
@ -87,6 +103,8 @@ private:
//- File name
fileName fileName_;
//- the actual reader
autoPtr<tableReader<Type> > reader_;
// Private Member Functions

181
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.C Normal file
View File

@ -0,0 +1,181 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "csvTableReader.H"
#include "IFstream.H"
#include "DynamicList.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::csvTableReader<Type>::csvTableReader(const dictionary& dict)
:
tableReader<Type>(dict),
headerLine_(readBool(dict.lookup("hasHeaderLine"))),
timeColumn_(readLabel(dict.lookup("timeColumn"))),
componentColumns_(dict.lookup("valueColumns")),
separator_(dict.lookupOrDefault<string>("separator", string(","))[0])
{
if (componentColumns_.size() != pTraits<Type>::nComponents)
{
FatalErrorIn("csvTableReader<Type>::csvTableReader(const dictionary&)")
<< componentColumns_ << " does not have the expected length "
<< pTraits<Type>::nComponents << endl
<< exit(FatalError);
}
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::csvTableReader<Type>::~csvTableReader()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
namespace Foam
{
// doesn't recognize specialization otherwise
template<>
scalar csvTableReader<scalar>::readValue(const List<string>& splitted)
{
if (componentColumns_[0] >= splitted.size())
{
FatalErrorIn
(
"csvTableReader<scalar>::readValue(const List<string>&)"
) << "No column " << componentColumns_[0] << " in "
<< splitted << endl
<< exit(FatalError);
}
return readScalar(IStringStream(splitted[componentColumns_[0]])());
}
template<class Type>
Type csvTableReader<Type>::readValue(const List<string>& splitted)
{
Type result;
for(label i = 0;i < pTraits<Type>::nComponents; i++)
{
if (componentColumns_[i] >= splitted.size())
{
FatalErrorIn
(
"csvTableReader<Type>::readValue(const List<string>&)"
) << "No column " << componentColumns_[i] << " in "
<< splitted << endl
<< exit(FatalError);
}
result[i] = readScalar
(
IStringStream(splitted[componentColumns_[i]])()
);
}
return result;
}
}
template<class Type>
void Foam::csvTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, Type> >& data
)
{
IFstream in(fName);
DynamicList<Tuple2<scalar, Type> > values;
// Skip header
if (headerLine_)
{
string line;
in.getLine(line);
}
while (in.good())
{
string line;
in.getLine(line);
DynamicList<string> splitted;
std::size_t pos = 0;
while (pos != std::string::npos)
{
std::size_t nPos = line.find(separator_, pos);
if (nPos == std::string::npos)
{
splitted.append(line.substr(pos));
pos=nPos;
}
else
{
splitted.append(line.substr(pos, nPos-pos));
pos=nPos+1;
}
}
if (splitted.size() <= 1)
{
break;
}
scalar time = readScalar(IStringStream(splitted[timeColumn_])());
Type value = readValue(splitted);
values.append(Tuple2<scalar,Type>(time, value));
}
data.transfer(values);
}
template<class Type>
void Foam::csvTableReader<Type>::write(Ostream& os) const
{
tableReader<Type>::write(os);
os.writeKeyword("hasHeaderLine")
<< headerLine_ << token::END_STATEMENT << nl;
os.writeKeyword("timeColumn")
<< timeColumn_ << token::END_STATEMENT << nl;
os.writeKeyword("valueColumns")
<< componentColumns_ << token::END_STATEMENT << nl;
os.writeKeyword("separator")
<< string(separator_) << token::END_STATEMENT << nl;
}
// ************************************************************************* //

123
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReader.H Normal file
View File

@ -0,0 +1,123 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::tableReader
Description
Reads an interpolation table from a file - CSV-format
SourceFiles
tableReader.C
\*---------------------------------------------------------------------------*/
#ifndef csvTableReader_H
#define csvTableReader_H
#include "tableReader.H"
#include "labelList.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class csvTableReader Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class csvTableReader
:
public tableReader<Type>
{
//- does the file have a header line?
const bool headerLine_;
//- column of the time
const label timeColumn_;
//- labels of the components
const labelList componentColumns_;
//- read the next value from the splitted string
Type readValue(const List<string>&);
//- separator character
const char separator_;
public:
//- Runtime type information
TypeName("csv");
// Constructors
//- Construct from dictionary
csvTableReader(const dictionary& dict);
//- Construct and return a copy
virtual autoPtr<tableReader<Type> > clone() const
{
return autoPtr<tableReader<Type> >
(
new csvTableReader<Type>
(
*this
)
);
}
//- Destructor
virtual ~csvTableReader();
// Member Functions
//- Read the table
virtual void operator()(const fileName&, List<Tuple2<scalar, Type> >&);
//- write the remaining parameters
virtual void write(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "csvTableReader.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

37
src/OpenFOAM/interpolations/interpolationTable/tableReaders/csv/csvTableReaders.C Normal file
View File

@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "csvTableReader.H"
#include "tableReaders.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeTableReaders(csvTableReader);
}
// ************************************************************************* //

59
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.C Normal file
View File

@ -0,0 +1,59 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "openFoamTableReader.H"
#include "IFstream.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::openFoamTableReader<Type>::openFoamTableReader(const dictionary& dict)
:
tableReader<Type>(dict)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::openFoamTableReader<Type>::~openFoamTableReader()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::openFoamTableReader<Type>::operator()
(
const fileName& fName,
List<Tuple2<scalar, Type> >& data
)
{
// Read data from file
IFstream(fName)() >> data;
}
// ************************************************************************* //

106
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReader.H Normal file
View File

@ -0,0 +1,106 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::tableReader
Description
Reads an interpolation table from a file - OpenFOAM-format
SourceFiles
tableReader.C
\*---------------------------------------------------------------------------*/
#ifndef openFoamTableReader_H
#define openFoamTableReader_H
#include "tableReader.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class openFoamTableReader Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class openFoamTableReader
:
public tableReader<Type>
{
public:
//- Runtime type information
TypeName("openFoam");
// Constructors
//- Construct from dictionary
openFoamTableReader(const dictionary &dict);
//- Construct and return a copy
virtual autoPtr<tableReader<Type> > clone() const
{
return autoPtr<tableReader<Type> >
(
new openFoamTableReader<Type>
(
*this
)
);
}
//- Destructor
virtual ~openFoamTableReader();
// Member functions
//- Read the table
virtual void operator()(const fileName&, List<Tuple2<scalar, Type> > &);
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "openFoamTableReader.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

37
src/OpenFOAM/interpolations/interpolationTable/tableReaders/openFoam/openFoamTableReaders.C Normal file
View File

@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "openFoamTableReader.H"
#include "tableReaders.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeTableReaders(openFoamTableReader);
}
// ************************************************************************* //

89
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.C Normal file
View File

@ -0,0 +1,89 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "tableReader.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
template<class Type>
Foam::autoPtr<Foam::tableReader<Type> > Foam::tableReader<Type>::New
(
const dictionary& spec
)
{
const word readerType = spec.lookupOrDefault<word>
(
"readerType",
"openFoam"
);
typename dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_
->find(readerType);
if (cstrIter == dictionaryConstructorTablePtr_->end())
{
FatalErrorIn
(
"tableReader::New(const dictionary&)"
) << "Unknown reader type " << readerType
<< nl << nl
<< "Valid reader types : " << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
return autoPtr<tableReader<Type> >(cstrIter()(spec));
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::tableReader<Type>::tableReader(const dictionary&)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::tableReader<Type>::~tableReader()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
void Foam::tableReader<Type>::write(Ostream& os) const
{
if (this->type() != "openFoam")
{
os.writeKeyword("readerType")
<< this->type() << token::END_STATEMENT << nl;
}
}
// ************************************************************************* //

128
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReader.H Normal file
View File

@ -0,0 +1,128 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::tableReader
Description
Base class to read table data for the interpolationTable
SourceFiles
tableReader.C
\*---------------------------------------------------------------------------*/
#ifndef tableReader_H
#define tableReader_H
#include "fileName.H"
#include "wordList.H"
#include "vector.H"
#include "tensor.H"
#include "typeInfo.H"
#include "runTimeSelectionTables.H"
#include "autoPtr.H"
#include "dictionary.H"
#include "Tuple2.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class tableReader Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class tableReader
{
public:
//- Runtime type information
TypeName("tableReader");
// Declare run-time constructor selection table
declareRunTimeSelectionTable
(
autoPtr,
tableReader,
dictionary,
(const dictionary& dict),
(dict)
);
// Constructors
//- Construct from dictionary
tableReader(const dictionary& dict);
//- Construct and return a clone
virtual autoPtr<tableReader<Type> > clone() const = 0;
// Selectors
//- Return a reference to the selected tableReader
static autoPtr<tableReader> New(const dictionary& spec);
//- Destructor
virtual ~tableReader();
// Member functions
//- Read the table
virtual void operator()
(
const fileName&,
List<Tuple2<scalar, Type> >&
) = 0;
//- Write additional information
virtual void write(Ostream& os) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "tableReader.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

50
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReaders.C Normal file
View File

@ -0,0 +1,50 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "tableReaders.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
#define defineTableReaderType(dataType) \
defineNamedTemplateTypeNameAndDebug(tableReader<dataType >, 0); \
defineTemplatedRunTimeSelectionTable(tableReader, dictionary, dataType);
defineTableReaderType(scalar);
defineTableReaderType(vector);
defineTableReaderType(sphericalTensor);
defineTableReaderType(symmTensor);
defineTableReaderType(tensor);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

78
src/OpenFOAM/interpolations/interpolationTable/tableReaders/tableReaders.H Normal file
View File

@ -0,0 +1,78 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::tableReader
SourceFiles
tableReaders.C
\*---------------------------------------------------------------------------*/
#ifndef tableReaders_H
#define tableReaders_H
#include "tableReader.H"
#include "fieldTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Only used internally
#define makeTypeTableReadersTypeName(typeTableReader, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeTableReader< dataType >, 0)
// Sometimes used externally
#define makeTableReadersTypeName(typeTableReader) \
\
makeTypeTableReadersTypeName(typeTableReader, scalar); \
makeTypeTableReadersTypeName(typeTableReader, vector); \
makeTypeTableReadersTypeName(typeTableReader, sphericalTensor); \
makeTypeTableReadersTypeName(typeTableReader, symmTensor); \
makeTypeTableReadersTypeName(typeTableReader, tensor)
// Define type info for single dataType template instantiation (eg, vector)
#define makeTableReaderType(typeTableReader, dataType) \
\
defineNamedTemplateTypeNameAndDebug(typeTableReader< dataType >, 0); \
addTemplatedToRunTimeSelectionTable \
( \
tableReader, typeTableReader, dataType, dictionary \
)
// Define type info for scalar, vector etc. instantiations
#define makeTableReaders(typeTableReader) \
\
makeTableReaderType(typeTableReader, scalar); \
makeTableReaderType(typeTableReader, vector); \
makeTableReaderType(typeTableReader, sphericalTensor); \
makeTableReaderType(typeTableReader, symmTensor); \
makeTableReaderType(typeTableReader, tensor)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

33
src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.C
View File

@ -34,7 +34,7 @@ namespace Foam
{
defineTypeNameAndDebug(coupledPolyPatch, 0);
scalar coupledPolyPatch::matchTol = 1E-3;
const scalar coupledPolyPatch::defaultMatchTol_ = 1E-4;
template<>
const char* NamedEnum<coupledPolyPatch::transformType, 4>::names[] =
@ -145,6 +145,7 @@ Foam::pointField Foam::coupledPolyPatch::getAnchorPoints
Foam::scalarField Foam::coupledPolyPatch::calcFaceTol
(
const scalar matchTol,
const UList<face>& faces,
const pointField& points,
const pointField& faceCentres
@ -313,7 +314,7 @@ void Foam::coupledPolyPatch::calcTransformTensors
forwardT_.setSize(0);
reverseT_.setSize(0);
separation_ = (nf&(Cr - Cf))*nf;
separation_ = Cr - Cf;
collocated_.setSize(separation_.size());
@ -401,7 +402,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
const polyBoundaryMesh& bm
)
:
polyPatch(name, size, start, index, bm)
polyPatch(name, size, start, index, bm),
matchTolerance_(defaultMatchTol_)
{}
@ -413,7 +415,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
const polyBoundaryMesh& bm
)
:
polyPatch(name, dict, index, bm)
polyPatch(name, dict, index, bm),
matchTolerance_(dict.lookupOrDefault("matchTolerance", defaultMatchTol_))
{}
@ -423,7 +426,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
const polyBoundaryMesh& bm
)
:
polyPatch(pp, bm)
polyPatch(pp, bm),
matchTolerance_(pp.matchTolerance_)
{}
@ -436,7 +440,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
const label newStart
)
:
polyPatch(pp, bm, index, newSize, newStart)
polyPatch(pp, bm, index, newSize, newStart),
matchTolerance_(pp.matchTolerance_)
{}
@ -449,7 +454,8 @@ Foam::coupledPolyPatch::coupledPolyPatch
const label newStart
)
:
polyPatch(pp, bm, index, mapAddressing, newStart)
polyPatch(pp, bm, index, mapAddressing, newStart),
matchTolerance_(pp.matchTolerance_)
{}
@ -459,4 +465,17 @@ Foam::coupledPolyPatch::~coupledPolyPatch()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::coupledPolyPatch::write(Ostream& os) const
{
polyPatch::write(os);
//if (matchTolerance_ != defaultMatchTol_)
{
os.writeKeyword("matchTolerance") << matchTolerance_
<< token::END_STATEMENT << nl;
}
}
// ************************************************************************* //

25
src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H
View File

@ -69,6 +69,12 @@ private:
// Private data
//- default matching tolerance
static const scalar defaultMatchTol_;
//- local matching tolerance
const scalar matchTolerance_;
//- offset (distance) vector from one side of the couple to the other
mutable vectorField separation_;
@ -81,14 +87,6 @@ private:
//- Are faces collocated. Either size 0,1 or length of patch.
mutable boolList collocated_;
public:
// Static data members
//- Relative tolerance (for geometric matching).
static scalar matchTol;
protected:
// Protected Member Functions
@ -105,7 +103,7 @@ protected:
const vectorField& nf,
const vectorField& nr,
const scalarField& smallDist,
const scalar absTol = matchTol,
const scalar absTol,
const transformType = UNKNOWN
) const;
@ -162,6 +160,7 @@ protected:
// from face centre to any of the face vertices.
static scalarField calcFaceTol
(
const scalar matchTol,
const UList<face>& faces,
const pointField& points,
const pointField& faceCentres
@ -295,6 +294,11 @@ public:
return collocated_;
}
scalar matchTolerance() const
{
return matchTolerance_;
}
//- Calculate the patch geometry
virtual void calcGeometry
@ -328,6 +332,9 @@ public:
labelList& faceMap,
labelList& rotation
) const = 0;
//- Write the polyPatch data as a dictionary
virtual void write(Ostream&) const;
};

230
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C
View File

@ -150,6 +150,7 @@ void Foam::cyclicPolyPatch::calcTransforms
}
// Some sanity checks
if (half0Ctrs.size() != half1Ctrs.size())
{
@ -163,11 +164,30 @@ void Foam::cyclicPolyPatch::calcTransforms
<< exit(FatalError);
}
if (transform_ != neighbPatch().transform_)
{
FatalErrorIn
(
"cyclicPolyPatch::calcTransforms()"
) << "Patch " << name()
<< " has transform type " << transformTypeNames[transform_]
<< ", neighbour patch " << neighbPatchName_
<< " has transform type "
<< neighbPatch().transformTypeNames[transform_]
<< exit(FatalError);
}
// Calculate transformation tensors
if (half0Ctrs.size() > 0)
{
vectorField half0Normals(half0Areas.size());
vectorField half1Normals(half1Areas.size());
scalar maxAreaDiff = -GREAT;
label maxAreaFacei = -1;
forAll(half0, facei)
{
scalar magSf = mag(half0Areas[facei]);
@ -182,35 +202,62 @@ void Foam::cyclicPolyPatch::calcTransforms
half0Normals[facei] = point(1, 0, 0);
half1Normals[facei] = half0Normals[facei];
}
else if (mag(magSf - nbrMagSf)/avSf > coupledPolyPatch::matchTol)
{
FatalErrorIn
(
"cyclicPolyPatch::calcTransforms()"
) << "face " << facei << " area does not match neighbour by "
<< 100*mag(magSf - nbrMagSf)/avSf
<< "% -- possible face ordering problem." << endl
<< "patch:" << name()
<< " my area:" << magSf
<< " neighbour area:" << nbrMagSf
<< " matching tolerance:" << coupledPolyPatch::matchTol
<< endl
<< "Mesh face:" << start()+facei
<< " fc:" << half0Ctrs[facei]
<< endl
<< "Neighbour fc:" << half1Ctrs[facei]
<< endl
<< "Rerun with cyclic debug flag set"
<< " for more information." << exit(FatalError);
}
else
{
half0Normals[facei] = half0Areas[facei] / magSf;
half1Normals[facei] = half1Areas[facei] / nbrMagSf;
scalar areaDiff = mag(magSf - nbrMagSf)/avSf;
if (areaDiff > maxAreaDiff)
{
maxAreaDiff = areaDiff;
maxAreaFacei = facei;
}
if (areaDiff > matchTolerance())
{
FatalErrorIn
(
"cyclicPolyPatch::calcTransforms()"
) << "face " << facei
<< " area does not match neighbour by "
<< 100*areaDiff
<< "% -- possible face ordering problem." << endl
<< "patch:" << name()
<< " my area:" << magSf
<< " neighbour area:" << nbrMagSf
<< " matching tolerance:" << matchTolerance()
<< endl
<< "Mesh face:" << start()+facei
<< " fc:" << half0Ctrs[facei]
<< endl
<< "Neighbour fc:" << half1Ctrs[facei]
<< endl
<< "If you are certain your matching is correct"
<< " you can increase the 'matchTolerance' setting"
<< " in the patch dictionary in the boundary file."
<< endl
<< "Rerun with cyclic debug flag set"
<< " for more information." << exit(FatalError);
}
else
{
half0Normals[facei] = half0Areas[facei] / magSf;
half1Normals[facei] = half1Areas[facei] / nbrMagSf;
}
}
}
// Print area match
if (debug)
{
Pout<< "cyclicPolyPatch::calcTransforms :"
<< " Max area error:" << 100*maxAreaDiff << "% at face:"
<< maxAreaFacei << " at:" << half0Ctrs[maxAreaFacei]
<< " coupled face at:" << half1Ctrs[maxAreaFacei]
<< endl;
}
// Calculate transformation tensors
if (transform_ == ROTATIONAL)
@ -259,6 +306,7 @@ void Foam::cyclicPolyPatch::calcTransforms
(
calcFaceTol
(
matchTolerance(),
half0,
half0.points(),
static_cast<const pointField&>(half0Ctrs)
@ -272,9 +320,74 @@ void Foam::cyclicPolyPatch::calcTransforms
half0Normals,
half1Normals,
half0Tols,
matchTol,
matchTolerance(),
transform_
);
if (transform_ == TRANSLATIONAL)
{
if (debug)
{
Pout<< "cyclicPolyPatch::calcTransforms :"
<< " Specified separation vector : "
<< separationVector_ << endl;
}
// Check that separation vectors are same.
const scalar avgTol = average(half0Tols);
if
(
mag(separationVector_ + neighbPatch().separationVector_)
> avgTol
)
{
WarningIn
(
"cyclicPolyPatch::calcTransforms()"
) << "Specified separation vector " << separationVector_
<< " differs by that of neighbouring patch "
<< neighbPatch().separationVector_
<< " by more than tolerance " << avgTol << endl
<< "patch:" << name()
<< " neighbour:" << neighbPatchName_
<< endl;
}
// Override computed transform with specified.
if
(
separation().size() != 1
|| mag(separation()[0] - separationVector_) > avgTol
)
{
WarningIn
(
"cyclicPolyPatch::calcTransforms()"
) << "Specified separationVector " << separationVector_
<< " differs from computed separation vector "
<< separation() << endl
<< "This probably means your geometry is not consistent"
<< " with the specified separation and might lead"
<< " to problems." << endl
<< "Continuing with specified separation vector "
<< separationVector_ << endl
<< "patch:" << name()
<< " neighbour:" << neighbPatchName_
<< endl;
}
// Set tensors
const_cast<tensorField&>(forwardT()).clear();
const_cast<tensorField&>(reverseT()).clear();
const_cast<vectorField&>(separation()) = vectorField
(
1,
separationVector_
);
const_cast<boolList&>(collocated()) = boolList(1, false);
}
}
}
}
@ -299,6 +412,16 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
anchors0 = getAnchorPoints(pp0, pp0.points());
half1Ctrs = pp1.faceCentres();
if (debug)
{
Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
<< " patch:" << name() << nl
<< "half0 untransformed faceCentres (avg) : "
<< gAverage(half0Ctrs) << nl
<< "half1 untransformed faceCentres (avg) : "
<< gAverage(half1Ctrs) << endl;
}
switch (transform_)
{
case ROTATIONAL:
@ -355,23 +478,24 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
break;
}
//- Problem: usually specified translation is not accurate enough
//- to get proper match so keep automatic determination over here.
//case TRANSLATIONAL:
//{
// // Transform 0 points.
//
// if (debug)
// {
// Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
// << "Specified translation : " << separationVector_
// << endl;
// }
//
// half0Ctrs += separationVector_;
// anchors0 += separationVector_;
// break;
//}
case TRANSLATIONAL:
{
// Transform 0 points.
if (debug)
{
Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
<< "Specified translation : " << separationVector_
<< endl;
}
// Note: getCentresAndAnchors gets called on the slave side
// so separationVector is owner-slave points.
half0Ctrs -= separationVector_;
anchors0 -= separationVector_;
break;
}
default:
{
// Assumes that cyclic is planar. This is also the initial
@ -387,7 +511,7 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
vector n1 = pp1[max1I].normal(pp1.points());
n1 /= mag(n1) + VSMALL;
if (mag(n0 & n1) < 1-coupledPolyPatch::matchTol)
if (mag(n0 & n1) < 1-matchTolerance())
{
if (debug)
{
@ -438,7 +562,7 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
// Calculate typical distance per face
tols = calcFaceTol(pp1, pp1.points(), half1Ctrs);
tols = calcFaceTol(matchTolerance(), pp1, pp1.points(), half1Ctrs);
}
@ -743,6 +867,9 @@ void Foam::cyclicPolyPatch::transformPosition(pointField& l) const
}
else if (separated())
{
// transformPosition gets called on the receiving side,
// separation gets calculated on the sending side so subtract.
const vectorField& s = separation();
if (s.size() == 1)
{
@ -1132,6 +1259,13 @@ bool Foam::cyclicPolyPatch::order
labelList& rotation
) const
{
if (debug)
{
Pout<< "order : of " << pp.size()
<< " faces of patch:" << name()
<< " neighbour:" << neighbPatchName_
<< endl;
}
faceMap.setSize(pp.size());
faceMap = -1;
@ -1174,6 +1308,14 @@ bool Foam::cyclicPolyPatch::order
tols
);
if (debug)
{
Pout<< "half0 transformed faceCentres (avg) : "
<< gAverage(half0Ctrs) << nl
<< "half1 untransformed faceCentres (avg) : "
<< gAverage(half1Ctrs) << endl;
}
// Geometric match of face centre vectors
bool matchedAll = matchPoints
(
@ -1308,7 +1450,7 @@ bool Foam::cyclicPolyPatch::order
void Foam::cyclicPolyPatch::write(Ostream& os) const
{
polyPatch::write(os);
coupledPolyPatch::write(os);
os.writeKeyword("neighbourPatch") << neighbPatchName_
<< token::END_STATEMENT << nl;
switch (transform_)

4
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/oldCyclic/oldCyclicPolyPatch.C
View File

@ -386,7 +386,7 @@ void Foam::oldCyclicPolyPatch::getCentresAndAnchors
vector n1 = half1Faces[max1I].normal(pp.points());
n1 /= mag(n1) + VSMALL;
if (mag(n0 & n1) < 1-coupledPolyPatch::matchTol)
if (mag(n0 & n1) < 1-matchTolerance())
{
if (debug)
{
@ -444,7 +444,7 @@ void Foam::oldCyclicPolyPatch::getCentresAndAnchors
// Calculate typical distance per face
tols = calcFaceTol(half1Faces, pp.points(), half1Ctrs);
tols = calcFaceTol(matchTolerance(), half1Faces, pp.points(), half1Ctrs);
}

20
src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -194,7 +194,7 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
faceNormals[facei] = point(1, 0, 0);
nbrFaceNormals[facei] = faceNormals[facei];
}
else if (mag(magSf - nbrMagSf)/avSf > coupledPolyPatch::matchTol)
else if (mag(magSf - nbrMagSf)/avSf > matchTolerance())
{
fileName nm
(
@ -214,12 +214,16 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
<< "patch:" << name()
<< " my area:" << magSf
<< " neighbour area:" << nbrMagSf
<< " matching tolerance:" << coupledPolyPatch::matchTol
<< " matching tolerance:" << matchTolerance()
<< endl
<< "Mesh face:" << start()+facei
<< " vertices:"
<< UIndirectList<point>(points(), operator[](facei))()
<< endl
<< "If you are certain your matching is correct"
<< " you can increase the 'matchTolerance' setting"
<< " in the patch dictionary in the boundary file."
<< endl
<< "Rerun with processor debug flag set for"
<< " more information." << exit(FatalError);
}
@ -236,7 +240,8 @@ void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
neighbFaceCentres_,
faceNormals,
nbrFaceNormals,
calcFaceTol(*this, points(), faceCentres())
calcFaceTol(matchTolerance(), *this, points(), faceCentres()),
matchTolerance()
);
}
}
@ -538,7 +543,10 @@ bool Foam::processorPolyPatch::order
}
// Calculate typical distance from face centre
scalarField tols(calcFaceTol(pp, pp.points(), pp.faceCentres()));
scalarField tols
(
calcFaceTol(matchTolerance(), pp, pp.points(), pp.faceCentres())
);
if (debug || masterCtrs.size() != pp.size())
{
@ -697,7 +705,7 @@ bool Foam::processorPolyPatch::order
void Foam::processorPolyPatch::write(Ostream& os) const
{
polyPatch::write(os);
coupledPolyPatch::write(os);
os.writeKeyword("myProcNo") << myProcNo_
<< token::END_STATEMENT << nl;
os.writeKeyword("neighbProcNo") << neighbProcNo_

37
src/OpenFOAM/primitives/globalIndexAndTransform/globalIndexAndTransform.C
View File

@ -125,6 +125,7 @@ void Foam::globalIndexAndTransform::determineTransforms()
const polyBoundaryMesh& patches = mesh_.boundaryMesh();
transforms_ = List<vectorTensorTransform>(6);
scalarField maxTol(6);
label nextTrans = 0;
@ -148,8 +149,6 @@ void Foam::globalIndexAndTransform::determineTransforms()
if (mag(sepVec) > SMALL)
{
scalar tol = coupledPolyPatch::matchTol;
vectorTensorTransform transform(sepVec);
if
@ -159,12 +158,13 @@ void Foam::globalIndexAndTransform::determineTransforms()
transforms_,
dummyMatch,
transform,
tol,
cpp.matchTolerance(),
false
) == 0
)
{
transforms_[nextTrans++] = transform;
transforms_[nextTrans] = transform;
maxTol[nextTrans++] = cpp.matchTolerance();
}
if (nextTrans > 6)
@ -191,8 +191,6 @@ void Foam::globalIndexAndTransform::determineTransforms()
if (mag(transT - I) > SMALL)
{
scalar tol = coupledPolyPatch::matchTol;
vectorTensorTransform transform(transT);
if
@ -202,12 +200,13 @@ void Foam::globalIndexAndTransform::determineTransforms()
transforms_,
dummyMatch,
transform,
tol,
cpp.matchTolerance(),
false
) == 0
)
{
transforms_[nextTrans++] = transform;
transforms_[nextTrans] = transform;
maxTol[nextTrans++] = cpp.matchTolerance();
}
if (nextTrans > 6)
@ -227,12 +226,18 @@ void Foam::globalIndexAndTransform::determineTransforms()
}
}
// Collect transforms on master
List<List<vectorTensorTransform> > allTransforms(Pstream::nProcs());
allTransforms[Pstream::myProcNo()] = transforms_;
Pstream::gatherList(allTransforms);
// Collect matching tolerance on master
List<scalarField> allTols(Pstream::nProcs());
allTols[Pstream::myProcNo()] = maxTol;
Pstream::gatherList(allTols);
if (Pstream::master())
{
transforms_ = List<vectorTensorTransform>(3);
@ -250,8 +255,6 @@ void Foam::globalIndexAndTransform::determineTransforms()
if (mag(transform.t()) > SMALL || transform.hasR())
{
scalar tol = coupledPolyPatch::matchTol;
if
(
matchTransform
@ -259,7 +262,7 @@ void Foam::globalIndexAndTransform::determineTransforms()
transforms_,
dummyMatch,
transform,
tol,
allTols[procI][pSVI],
true
) == 0
)
@ -378,8 +381,6 @@ void Foam::globalIndexAndTransform::determinePatchTransformSign()
if (mag(sepVec) > SMALL)
{
scalar tol = coupledPolyPatch::matchTol;
vectorTensorTransform t(sepVec);
label sign = matchTransform
@ -387,7 +388,7 @@ void Foam::globalIndexAndTransform::determinePatchTransformSign()
transforms_,
matchTransI,
t,
tol,
cpp.matchTolerance(),
true
);
@ -424,8 +425,6 @@ void Foam::globalIndexAndTransform::determinePatchTransformSign()
if (mag(transT - I) > SMALL)
{
scalar tol = coupledPolyPatch::matchTol;
vectorTensorTransform t(transT);
label sign = matchTransform
@ -433,7 +432,7 @@ void Foam::globalIndexAndTransform::determinePatchTransformSign()
transforms_,
matchTransI,
t,
tol,
cpp.matchTolerance(),
true
);

4
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingFlowRateInletVelocity/timeVaryingFlowRateInletVelocityFvPatchVectorField.H
View File

@ -25,7 +25,9 @@ Class
Foam::timeVaryingFlowRateInletVelocityFvPatchVectorField
Description
A time-varying form of a flow normal vector boundary condition.
A time-varying form of a flow normal vector boundary condition. The
variation is specified as an interpolationTable (see
Foam::interpolationTable).
Example of the boundary condition specification:
\verbatim

4
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFvPatchField.H
View File

@ -25,7 +25,9 @@ Class
Foam::timeVaryingUniformFixedValueFvPatchField
Description
A time-varying form of a uniform fixed value boundary condition.
A time-varying form of a uniform fixed value boundary condition. The
variation is specified as an interpolationTable (see
Foam::interpolationTable for read options).
Example of the boundary condition specification:
\verbatim

6
src/finiteVolume/fields/fvPatchFields/derived/timeVaryingUniformTotalPressure/timeVaryingUniformTotalPressureFvPatchScalarField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,7 +25,9 @@ Class
Foam::timeVaryingUniformTotalPressureFvPatchScalarField
Description
A time-varying form of a uniform total pressure boundary condition.
A time-varying form of a uniform total pressure boundary condition. The
variation is specified as an interpolationTable (see
Foam::interpolationTable).
See Also
Foam::timeVaryingUniformFixedValueFvPatchField

13
src/finiteVolume/fvMesh/fvPatches/constraint/cyclic/cyclicFvPatch.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -52,17 +52,6 @@ void Foam::cyclicFvPatch::makeWeights(scalarField& w) const
forAll(magFa, facei)
{
scalar avFa = (magFa[facei] + nbrMagFa[facei])/2.0;
if (mag(magFa[facei] - nbrMagFa[facei])/avFa > 1e-4)
{
FatalErrorIn("cyclicFvPatch::makeWeights(scalarField&) const")
<< "face " << facei << " areas do not match by "
<< 100*mag(magFa[facei] - nbrMagFa[facei])/avFa
<< "% -- possible face ordering problem"
<< abort(FatalError);
}
scalar di = deltas[facei];
scalar dni = nbrDeltas[facei];

2
src/fvAgglomerationMethods/Allwmake
View File

@ -10,6 +10,6 @@ then
wmake $makeType MGridGenGamgAgglomeration
fi
wmake libso pairPatchAgglomeration
wmake $makeType pairPatchAgglomeration
# ----------------------------------------------------------------- end-of-file

262
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
View File

@ -251,6 +251,7 @@ void Foam::autoLayerDriver::handleNonManifolds
(
const indirectPrimitivePatch& pp,
const labelList& meshEdges,
const labelListList& edgeGlobalFaces,
pointField& patchDisp,
labelList& patchNLayers,
List<extrudeMode>& extrudeStatus
@ -268,11 +269,50 @@ void Foam::autoLayerDriver::handleNonManifolds
// 1. Local check
checkManifold(pp, nonManifoldPoints);
// 2. Remote check for boundary edges on coupled boundaries
forAll(edgeGlobalFaces, edgeI)
{
if
(
pp.edgeFaces()[edgeI].size() == 1
&& edgeGlobalFaces[edgeI].size() > 2
)
{
// So boundary edges that are connected to more than 2 processors
// i.e. a non-manifold edge which is exactly on a processor
// boundary.
const edge& e = pp.edges()[edgeI];
nonManifoldPoints.insert(pp.meshPoints()[e[0]]);
nonManifoldPoints.insert(pp.meshPoints()[e[1]]);
}
}
label nNonManif = returnReduce(nonManifoldPoints.size(), sumOp<label>());
Info<< "Outside of local patch is multiply connected across edges or"
<< " points at " << nNonManif << " points." << endl;
if (nNonManif > 0)
{
const labelList& meshPoints = pp.meshPoints();
forAll(meshPoints, patchPointI)
{
if (nonManifoldPoints.found(meshPoints[patchPointI]))
{
unmarkExtrusion
(
patchPointI,
patchDisp,
patchNLayers,
extrudeStatus
);
}
}
}
Info<< "Set displacement to zero for all " << nNonManif
<< " non-manifold points" << endl;
}
@ -1309,11 +1349,109 @@ void Foam::autoLayerDriver::getPatchDisplacement
}
bool Foam::autoLayerDriver::sameEdgeNeighbour
(
const labelListList& globalEdgeFaces,
const label myGlobalFaceI,
const label nbrGlobFaceI,
const label edgeI
) const
{
const labelList& eFaces = globalEdgeFaces[edgeI];
if (eFaces.size() == 2)
{
return edge(myGlobalFaceI, nbrGlobFaceI) == edge(eFaces[0], eFaces[1]);
}
else
{
return false;
}
}
void Foam::autoLayerDriver::getVertexString
(
const indirectPrimitivePatch& pp,
const labelListList& globalEdgeFaces,
const label faceI,
const label edgeI,
const label myGlobFaceI,
const label nbrGlobFaceI,
DynamicList<label>& vertices
) const
{
const labelList& fEdges = pp.faceEdges()[faceI];
label fp = findIndex(fEdges, edgeI);
if (fp == -1)
{
FatalErrorIn("autoLayerDriver::getVertexString(..)")
<< "problem." << abort(FatalError);
}
// Search back
label startFp = fp;
forAll(fEdges, i)
{
label prevFp = fEdges.rcIndex(startFp);
if
(
!sameEdgeNeighbour
(
globalEdgeFaces,
myGlobFaceI,
nbrGlobFaceI,
fEdges[prevFp]
)
)
{
break;
}
startFp = prevFp;
}
label endFp = fp;
forAll(fEdges, i)
{
label nextFp = fEdges.fcIndex(endFp);
if
(
!sameEdgeNeighbour
(
globalEdgeFaces,
myGlobFaceI,
nbrGlobFaceI,
fEdges[nextFp]
)
)
{
break;
}
endFp = nextFp;
}
const face& f = pp.localFaces()[faceI];
vertices.clear();
fp = startFp;
while (fp != endFp)
{
vertices.append(f[fp]);
fp = f.fcIndex(fp);
}
vertices.append(f[fp]);
fp = f.fcIndex(fp);
vertices.append(f[fp]);
}
// Truncates displacement
// - for all patchFaces in the faceset displacement gets set to zero
// - all displacement < minThickness gets set to zero
Foam::label Foam::autoLayerDriver::truncateDisplacement
(
const globalIndex& globalFaces,
const labelListList& edgeGlobalFaces,
const motionSmoother& meshMover,
const scalarField& minThickness,
const faceSet& illegalPatchFaces,
@ -1405,6 +1543,10 @@ Foam::label Foam::autoLayerDriver::truncateDisplacement
extrudeStatus
);
// Pinch
// ~~~~~
// Make sure that a face doesn't have two non-consecutive areas
// not extruded (e.g. quad where vertex 0 and 2 are not extruded
// but 1 and 3 are) since this gives topological errors.
@ -1457,6 +1599,112 @@ Foam::label Foam::autoLayerDriver::truncateDisplacement
<< " faces due to non-consecutive vertices being extruded." << endl;
// Butterfly
// ~~~~~~~~~
// Make sure that a string of edges becomes a single face so
// not a butterfly. Occassionally an 'edge' will have a single dangling
// vertex due to face combining. These get extruded as a single face
// (with a dangling vertex) so make sure this extrusion forms a single
// shape.
// - continuous i.e. no butterfly:
// + +
// |\ /|
// | \ / |
// +--+--+
// - extrudes from all but the endpoints i.e. no partial
// extrude
// +
// /|
// / |
// +--+--+
// The common error topology is a pinch somewhere in the middle
label nButterFly = 0;
{
DynamicList<label> stringedVerts;
forAll(pp.edges(), edgeI)
{
const labelList& globFaces = edgeGlobalFaces[edgeI];
if (globFaces.size() == 2)
{
label myFaceI = pp.edgeFaces()[edgeI][0];
label myGlobalFaceI = globalFaces.toGlobal
(
pp.addressing()[myFaceI]
);
label nbrGlobalFaceI =
(
globFaces[0] != myGlobalFaceI
? globFaces[0]
: globFaces[1]
);
getVertexString
(
pp,
edgeGlobalFaces,
myFaceI,
edgeI,
myGlobalFaceI,
nbrGlobalFaceI,
stringedVerts
);
if
(
extrudeStatus[stringedVerts[0]] != NOEXTRUDE
|| extrudeStatus[stringedVerts.last()] != NOEXTRUDE
)
{
// Any pinch in the middle
bool pinch = false;
for (label i = 1; i < stringedVerts.size()-1; i++)
{
if
(
extrudeStatus[stringedVerts[i]] == NOEXTRUDE
)
{
pinch = true;
break;
}
}
if (pinch)
{
forAll(stringedVerts, i)
{
if
(
unmarkExtrusion
(
stringedVerts[i],
patchDisp,
patchNLayers,
extrudeStatus
)
)
{
nButterFly++;
nChanged++;
}
}
}
}
}
}
}
reduce(nButterFly, sumOp<label>());
Info<< "truncateDisplacement : Unextruded " << nButterFly
<< " faces due to stringed edges with inconsistent extrusion."
<< endl;
// Consistent number of layers
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Make sure that a face has consistent number of layers for all
// its vertices.
@ -1504,7 +1752,7 @@ Foam::label Foam::autoLayerDriver::truncateDisplacement
//Info<< "truncateDisplacement : Unextruded " << nDiffering
// << " faces due to having differing number of layers." << endl;
if (nPinched+nDiffering == 0)
if (nPinched+nButterFly+nDiffering == 0)
{
break;
}
@ -1536,7 +1784,7 @@ void Foam::autoLayerDriver::setupLayerInfoTruncation
Info<< nl << "Performing no layer truncation."
<< " nBufferCellsNoExtrude set to less than 0 ..." << endl;
// Face layers if any point get extruded
// Face layers if any point gets extruded
forAll(pp.localFaces(), patchFaceI)
{
const face& f = pp.localFaces()[patchFaceI];
@ -2066,6 +2314,7 @@ void Foam::autoLayerDriver::addLayers
(
pp,
meshEdges,
edgeGlobalFaces,
patchDisp,
patchNLayers,
@ -2408,10 +2657,13 @@ void Foam::autoLayerDriver::addLayers
}
// Truncate displacements that are too small (this will do internal
// ones, coupled ones have already been truncated by syncPatch)
// ones, coupled ones have already been truncated by
// syncPatchDisplacement)
faceSet dummySet(mesh, "wrongPatchFaces", 0);
truncateDisplacement
(
globalFaces,
edgeGlobalFaces,
meshMover(),
minThickness,
dummySet,
@ -2467,9 +2719,9 @@ void Foam::autoLayerDriver::addLayers
// (first layer = layer of cells next to the original mesh)
vectorField firstDisp(patchNLayers.size(), vector::zero);
forAll(patchNLayers, i)
forAll(nPatchPointLayers, i)
{
if (patchNLayers[i] > 0)
if (nPatchPointLayers[i] > 0)
{
if (expansionRatio[i] == 1.0)
{

25
src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.H
View File

@ -153,6 +153,7 @@ class autoLayerDriver
(
const indirectPrimitivePatch& pp,
const labelList& meshEdges,
const labelListList& edgeGlobalFaces,
pointField& patchDisp,
labelList& patchNLayers,
List<extrudeMode>& extrudeStatus
@ -261,12 +262,36 @@ class autoLayerDriver
List<extrudeMode>& extrudeStatus
) const;
//- for truncateDisplacement: find strings of edges
bool sameEdgeNeighbour
(
const labelListList& globalEdgeFaces,
const label myGlobalFaceI,
const label nbrGlobFaceI,
const label edgeI
) const;
//- for truncateDisplacement: find strings of edges
void getVertexString
(
const indirectPrimitivePatch& pp,
const labelListList& globalEdgeFaces,
const label faceI,
const label edgeI,
const label myGlobFaceI,
const label nbrGlobFaceI,
DynamicList<label>& vertices
) const;
//- Truncates displacement
// - for all patchFaces in the faceset displacement gets set
// to zero
// - all displacement < minThickness gets set to zero
// - all non-consecutive extrusions get set to 0
label truncateDisplacement
(
const globalIndex& globalFaces,
const labelListList& edgeGlobalFaces,
const motionSmoother& meshMover,
const scalarField& minThickness,
const faceSet& illegalPatchFaces,

9
src/regionModels/Allwmake
View File

@ -1,11 +1,12 @@
#!/bin/sh
cd ${0%/*} || exit 1 # run from this directory
makeType=${1:-libso}
set -x
wmake libso regionModel
#wmake libso pyrolysisModels
wmake libso surfaceFilmModels
#wmake libso regionCoupling
wmake $makeType regionModel
#wmake $makeType pyrolysisModels
wmake $makeType surfaceFilmModels
#wmake $makeType regionCoupling
# ----------------------------------------------------------------- end-of-file

2262
src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.C
View File

File diff suppressed because it is too large Load Diff

1046
src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
View File

File diff suppressed because it is too large Load Diff

2
src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H
View File

@ -107,7 +107,7 @@ protected:
tmp<volScalarField> calcInvR1(const volVectorField& U) const;
//- Calculate the cosine of the angle between gravity vector and
// cell out flow direction
// cell out flow direction
tmp<scalarField> calcCosAngle(const surfaceScalarField& phi) const;

2
src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/phaseChangeModel/phaseChangeModel.C
View File

@ -91,7 +91,7 @@ void phaseChangeModel::correct
);
latestMassPC_ = sum(dMass.internalField());
totalMassPC_ += latestMassPC_;
totalMassPC_ += latestMassPC_;
availableMass -= dMass;
dMass.correctBoundaryConditions();

1
src/sampling/Make/files
View File

@ -24,6 +24,7 @@ $(setWriters)/jplot/jplotSetWriterRunTime.C
$(setWriters)/raw/rawSetWriterRunTime.C
$(setWriters)/vtk/vtkSetWriterRunTime.C
$(setWriters)/xmgrace/xmgraceSetWriterRunTime.C
$(setWriters)/csv/csvSetWriterRunTime.C
cuttingPlane/cuttingPlane.C

202
src/sampling/sampledSet/writers/csv/csvSetWriter.C Normal file
View File

@ -0,0 +1,202 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "csvSetWriter.H"
#include "coordSet.H"
#include "fileName.H"
#include "OFstream.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::csvSetWriter<Type>::csvSetWriter()
:
writer<Type>()
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::csvSetWriter<Type>::~csvSetWriter()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class Type>
Foam::fileName Foam::csvSetWriter<Type>::getFileName
(
const coordSet& points,
const wordList& valueSetNames
) const
{
return this->getBaseName(points, valueSetNames) + ".csv";
}
template<class Type>
void Foam::csvSetWriter<Type>::write
(
const coordSet& points,
const wordList& valueSetNames,
const List<const Field<Type>*>& valueSets,
Ostream& os
) const
{
writeHeader(points,valueSetNames,os);
// Collect sets into columns
List<const List<Type>*> columns(valueSets.size());
forAll(valueSets, i)
{
columns[i] = valueSets[i];
}
writeTable(points, columns, os);
}
template<class Type>
void Foam::csvSetWriter<Type>::write
(
const bool writeTracks,
const PtrList<coordSet>& points,
const wordList& valueSetNames,
const List<List<Field<Type> > >& valueSets,
Ostream& os
) const
{
writeHeader(points[0],valueSetNames,os);
if (valueSets.size() != valueSetNames.size())
{
FatalErrorIn("csvSetWriter<Type>::write(..)")
<< "Number of variables:" << valueSetNames.size() << endl
<< "Number of valueSets:" << valueSets.size()
<< exit(FatalError);
}
List<const List<Type>*> columns(valueSets.size());
forAll(points, trackI)
{
// Collect sets into columns
forAll(valueSets, i)
{
columns[i] = &valueSets[i][trackI];
}
writeTable(points[trackI], columns, os);
os << nl << nl;
}
}
template<class Type>
void Foam::csvSetWriter<Type>::writeSeparator(Ostream& os) const
{
os << token::COMMA;
}
namespace Foam
{
// otherwise compiler complains about specialization
template<>
void csvSetWriter<scalar>::writeHeader
(
const coordSet& points,
const wordList& valueSetNames,
Ostream& os
) const
{
writeCoordHeader(points, os);
forAll(valueSetNames, i)
{
if (i > 0)
{
writeSeparator(os);
}
os << valueSetNames[i];
}
os << nl;
}
} // end namespace
template<class Type>
void Foam::csvSetWriter<Type>::writeHeader
(
const coordSet& points,
const wordList& valueSetNames,
Ostream& os
) const
{
writeCoordHeader(points, os);
forAll(valueSetNames, i)
{
for (label j=0; j<Type::nComponents; j++)
{
if (i>0 || j>0)
{
writeSeparator(os);
}
os << valueSetNames[i] << "_" << j;
}
}
os << nl;
}
template<class Type>
void Foam::csvSetWriter<Type>::writeCoordHeader
(
const coordSet& points,
Ostream& os
) const
{
if (points.hasVectorAxis())
{
forAll(points, i)
{
os << points.axis()[i];
writeSeparator(os);
}
}
else
{
os << points.axis();
writeSeparator(os);
}
}
// ************************************************************************* //

122
src/sampling/sampledSet/writers/csv/csvSetWriter.H Normal file
View File

@ -0,0 +1,122 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::csvSetWriter
Description
SourceFiles
csvSetWriter.C
\*---------------------------------------------------------------------------*/
#ifndef csvSetWriter_H
#define csvSetWriter_H
#include "writer.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class csvSetWriter Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class csvSetWriter
:
public writer<Type>
{
// Private Member Functions
void writeCoordHeader(const coordSet&, Ostream&) const;
void writeHeader(const coordSet&, const wordList&, Ostream&) const;
protected:
virtual void writeSeparator(Ostream&) const;
public:
//- Runtime type information
TypeName("csv");
// Constructors
//- Construct null
csvSetWriter();
//- Destructor
virtual ~csvSetWriter();
// Member Functions
virtual fileName getFileName
(
const coordSet&,
const wordList&
) const;
virtual void write
(
const coordSet&,
const wordList&,
const List<const Field<Type>*>&,
Ostream&
) const;
virtual void write
(
const bool writeTracks,
const PtrList<coordSet>&,
const wordList& valueSetNames,
const List<List<Field<Type> > >&,
Ostream&
) const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
# include "csvSetWriter.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

37
src/sampling/sampledSet/writers/csv/csvSetWriterRunTime.C Normal file
View File

@ -0,0 +1,37 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 1991-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "csvSetWriter.H"
#include "writers.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
makeSetWriters(csvSetWriter);
}
// ************************************************************************* //

26
src/sampling/sampledSet/writers/writer.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2004-2010 OpenCFD Ltd.
\\ / A nd | Copyright (C) 2004-2011 OpenCFD Ltd.
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -105,8 +105,7 @@ void Foam::writer<Type>::writeTable
forAll(points, pointI)
{
writeCoord(points, pointI, os);
os << token::SPACE;
writeSeparator(os);
write(values[pointI], os);
os << nl;
}
@ -127,7 +126,8 @@ void Foam::writer<Type>::writeTable
forAll(valuesPtrList, i)
{
os << token::SPACE;
writeSeparator(os);
const List<Type>& values = *valuesPtrList[i];
write(values[pointI], os);
}
@ -173,17 +173,27 @@ Foam::Ostream& Foam::writer<Type>::writeVS
{
for (direction d=0; d<VSType::nComponents; d++)
{
os << value.component(d);
if (d <= VSType::nComponents-1)
if (d > 0)
{
os << ' ' << token::TAB;
writeSeparator(os);
}
os << value.component(d);
}
return os;
}
template<class Type>
void Foam::writer<Type>::writeSeparator
(
Ostream& os
) const
{
os << token::SPACE << token::TAB;
}
template<class Type>
Foam::Ostream& Foam::writer<Type>::write
(

2
src/sampling/sampledSet/writers/writer.H
View File

@ -107,6 +107,8 @@ protected:
Ostream& os
) const;
//- Writes a separator. Used by write functions.
virtual void writeSeparator(Ostream& os) const;
public: