zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Update code to use the simpler C++11 template syntax removing spaces between closing ">"s

Browse Source
This commit is contained in:
Henry Weller
2016-01-10 22:41:16 +00:00
parent 36f2d69888
commit 94c05a1e6c
1426 changed files with 8375 additions and 8375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -148,7 +148,7 @@ bool Foam::dynamicIndexedOctree<Type>::overlaps
template<class Type>
void Foam::dynamicIndexedOctree<Type>::divide
(
const autoPtr<DynamicList<label> >& indices,
const autoPtr<DynamicList<label>>& indices,
const treeBoundBox& bb,
contentListList& result
) const
@ -157,7 +157,7 @@ void Foam::dynamicIndexedOctree<Type>::divide
{
result.append
(
autoPtr<DynamicList<label> >
autoPtr<DynamicList<label>>
(
new DynamicList<label>(indices().size()/8)
)
@ -197,7 +197,7 @@ Foam::dynamicIndexedOctree<Type>::divide
const label octantToBeDivided
)
{
const autoPtr<DynamicList<label> >& indices = contents_[contentI];
const autoPtr<DynamicList<label>>& indices = contents_[contentI];
node nod;
@ -226,7 +226,7 @@ Foam::dynamicIndexedOctree<Type>::divide
for (direction octant = 0; octant < dividedIndices.size(); octant++)
{
autoPtr<DynamicList<label> >& subIndices = dividedIndices[octant];
autoPtr<DynamicList<label>>& subIndices = dividedIndices[octant];
if (subIndices().size())
{
@ -245,7 +245,7 @@ Foam::dynamicIndexedOctree<Type>::divide
contents_.append
(
autoPtr<DynamicList<label> >
autoPtr<DynamicList<label>>
(
new DynamicList<label>()
)
@ -2677,7 +2677,7 @@ bool Foam::dynamicIndexedOctree<Type>::insert(label startIndex, label endIndex)
{
contents_.append
(
autoPtr<DynamicList<label> >
autoPtr<DynamicList<label>>
(
new DynamicList<label>(1)
)
@ -2771,7 +2771,7 @@ bool Foam::dynamicIndexedOctree<Type>::insertIndex
contents_.append
(
autoPtr<DynamicList<label> >(new DynamicList<label>(1))
autoPtr<DynamicList<label>>(new DynamicList<label>(1))
);
contents_[sz]().append(index);

10
src/OpenFOAM/algorithms/dynamicIndexedOctree/dynamicIndexedOctree.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ SourceFiles
namespace Foam
{
typedef DynamicList<autoPtr<DynamicList<label > > > contentListList;
typedef DynamicList<autoPtr<DynamicList<label >>> contentListList;
// Forward declaration of classes
template<class Type> class dynamicIndexedOctree;
@ -181,7 +181,7 @@ private:
// according to where they are in relation to mid.
void divide
(
const autoPtr<DynamicList<label> >& indices,
const autoPtr<DynamicList<label>>& indices,
const treeBoundBox& bb,
contentListList& result
) const;
@ -435,9 +435,9 @@ public:
);
//- Clone
autoPtr<dynamicIndexedOctree<Type> > clone() const
autoPtr<dynamicIndexedOctree<Type>> clone() const
{
return autoPtr<dynamicIndexedOctree<Type> >
return autoPtr<dynamicIndexedOctree<Type>>
(
new dynamicIndexedOctree<Type>(*this)
);

4
src/OpenFOAM/algorithms/indexedOctree/indexedOctree.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -127,7 +127,7 @@ void Foam::indexedOctree<Type>::divide
labelListList& result
) const
{
List<DynamicList<label> > subIndices(8);
List<DynamicList<label>> subIndices(8);
for (direction octant = 0; octant < subIndices.size(); octant++)
{
subIndices[octant].setCapacity(indices.size()/8);

6
src/OpenFOAM/algorithms/indexedOctree/indexedOctree.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -434,9 +434,9 @@ public:
indexedOctree(const Type& shapes, Istream& is);
//- Clone
autoPtr<indexedOctree<Type> > clone() const
autoPtr<indexedOctree<Type>> clone() const
{
return autoPtr<indexedOctree<Type> >
return autoPtr<indexedOctree<Type>>
(
new indexedOctree<Type>(*this)
);

8
src/OpenFOAM/containers/HashTables/HashSet/HashSet.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -92,13 +92,13 @@ public:
{}
//- Construct by transferring the parameter contents
HashSet(const Xfer<HashSet<Key, Hash> >& hs)
HashSet(const Xfer<HashSet<Key, Hash>>& hs)
:
HashTable<nil, Key, Hash>(hs)
{}
//- Construct by transferring the parameter contents
HashSet(const Xfer<HashTable<nil, Key, Hash> >& hs)
HashSet(const Xfer<HashTable<nil, Key, Hash>>& hs)
:
HashTable<nil, Key, Hash>(hs)
{}
@ -208,7 +208,7 @@ HashSet<Key,Hash> operator^
typedef HashSet<> wordHashSet;
//- A HashSet with label keys.
typedef HashSet<label, Hash<label> > labelHashSet;
typedef HashSet<label, Hash<label>> labelHashSet;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

4
src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -78,7 +78,7 @@ Foam::HashTable<T, Key, Hash>::HashTable(const HashTable<T, Key, Hash>& ht)
template<class T, class Key, class Hash>
Foam::HashTable<T, Key, Hash>::HashTable
(
const Xfer<HashTable<T, Key, Hash> >& ht
const Xfer<HashTable<T, Key, Hash>>& ht
)
:
HashTableCore(),

6
src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -205,7 +205,7 @@ public:
HashTable(const HashTable<T, Key, Hash>&);
//- Construct by transferring the parameter contents
HashTable(const Xfer<HashTable<T, Key, Hash> >&);
HashTable(const Xfer<HashTable<T, Key, Hash>>&);
//- Destructor
@ -290,7 +290,7 @@ public:
void transfer(HashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer<HashTable<T, Key, Hash> > xfer();
inline Xfer<HashTable<T, Key, Hash>> xfer();
// Member Operators

4
src/OpenFOAM/containers/HashTables/HashTable/HashTableI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -98,7 +98,7 @@ inline bool Foam::HashTable<T, Key, Hash>::set
template<class T, class Key, class Hash>
inline Foam::Xfer<Foam::HashTable<T, Key, Hash> >
inline Foam::Xfer<Foam::HashTable<T, Key, Hash>>
Foam::HashTable<T, Key, Hash>::xfer()
{
return xferMove(*this);

22
src/OpenFOAM/containers/HashTables/Map/Map.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,14 +49,14 @@ namespace Foam
template<class T>
class Map
:
public HashTable<T, label, Hash<label> >
public HashTable<T, label, Hash<label>>
{
public:
typedef typename HashTable<T, label, Hash<label> >::iterator iterator;
typedef typename HashTable<T, label, Hash<label>>::iterator iterator;
typedef typename HashTable<T, label, Hash<label> >::const_iterator
typedef typename HashTable<T, label, Hash<label>>::const_iterator
const_iterator;
// Constructors
@ -64,31 +64,31 @@ public:
//- Construct given initial size
Map(const label size = 128)
:
HashTable<T, label, Hash<label> >(size)
HashTable<T, label, Hash<label>>(size)
{}
//- Construct from Istream
Map(Istream& is)
:
HashTable<T, label, Hash<label> >(is)
HashTable<T, label, Hash<label>>(is)
{}
//- Construct as copy
Map(const Map<T>& map)
:
HashTable<T, label, Hash<label> >(map)
HashTable<T, label, Hash<label>>(map)
{}
//- Construct by transferring the parameter contents
Map(const Xfer<Map<T> >& map)
Map(const Xfer<Map<T>>& map)
:
HashTable<T, label, Hash<label> >(map)
HashTable<T, label, Hash<label>>(map)
{}
//- Construct by transferring the parameter contents
Map(const Xfer<HashTable<T, label, Hash<label> > >& map)
Map(const Xfer<HashTable<T, label, Hash<label>>>& map)
:
HashTable<T, label, Hash<label> >(map)
HashTable<T, label, Hash<label>>(map)
{}
};

10
src/OpenFOAM/containers/HashTables/PtrMap/PtrMap.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,7 +49,7 @@ namespace Foam
template<class T>
class PtrMap
:
public HashPtrTable<T, label, Hash<label> >
public HashPtrTable<T, label, Hash<label>>
{
public:
@ -59,19 +59,19 @@ public:
//- Construct given initial map size
PtrMap(const label size = 128)
:
HashPtrTable<T, label, Hash<label> >(size)
HashPtrTable<T, label, Hash<label>>(size)
{}
//- Construct from Istream
PtrMap(Istream& is)
:
HashPtrTable<T, label, Hash<label> >(is)
HashPtrTable<T, label, Hash<label>>(is)
{}
//- Construct as copy
PtrMap(const PtrMap<T>& map)
:
HashPtrTable<T, label, Hash<label> >(map)
HashPtrTable<T, label, Hash<label>>(map)
{}
};

4
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -97,7 +97,7 @@ Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
template<class T, class Key, class Hash>
Foam::StaticHashTable<T, Key, Hash>::StaticHashTable
(
const Xfer<StaticHashTable<T, Key, Hash> >& ht
const Xfer<StaticHashTable<T, Key, Hash>>& ht
)
:
StaticHashTableCore(),

10
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -111,10 +111,10 @@ class StaticHashTable
// Private data type for table entries
//- The lookup keys, ordered per hash value
List<List<Key> > keys_;
List<List<Key>> keys_;
//- For each key the corresponding object.
List<List<T> > objects_;
List<List<T>> objects_;
//- The current number of elements in table
label nElmts_;
@ -178,7 +178,7 @@ public:
StaticHashTable(const StaticHashTable<T, Key, Hash>&);
//- Construct by transferring the parameter contents
StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash> >&);
StaticHashTable(const Xfer<StaticHashTable<T, Key, Hash>>&);
//- Destructor
@ -246,7 +246,7 @@ public:
void transfer(StaticHashTable<T, Key, Hash>&);
//- Transfer contents to the Xfer container
inline Xfer<StaticHashTable<T, Key, Hash> > xfer();
inline Xfer<StaticHashTable<T, Key, Hash>> xfer();
// Member Operators

4
src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTableI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -78,7 +78,7 @@ inline bool Foam::StaticHashTable<T, Key, Hash>::set
template<class T, class Key, class Hash>
inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash> >
inline Foam::Xfer<Foam::StaticHashTable<T, Key, Hash>>
Foam::StaticHashTable<T, Key, Hash>::xfer()
{
return xferMove(*this);

6
src/OpenFOAM/containers/Identifiers/Keyed/Keyed.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -69,14 +69,14 @@ public:
// Static Members
//- Add labels to a list of values
inline static List<Keyed<T> > createList
inline static List<Keyed<T>> createList
(
const List<T>&,
const label key=0
);
//- Add labels to a list of values
inline static List<Keyed<T> > createList
inline static List<Keyed<T>> createList
(
const List<T>&,
const labelUList& keys

10
src/OpenFOAM/containers/Identifiers/Keyed/KeyedI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -75,10 +75,10 @@ inline Foam::label& Foam::Keyed<T>::key()
template<class T>
inline Foam::List<Foam::Keyed<T> >
inline Foam::List<Foam::Keyed<T>>
Foam::Keyed<T>::createList(const List<T>& lst, const label key)
{
List<Keyed<T> > newList(lst.size());
List<Keyed<T>> newList(lst.size());
forAll(lst, elemI)
{
@ -89,7 +89,7 @@ Foam::Keyed<T>::createList(const List<T>& lst, const label key)
template<class T>
inline Foam::List<Foam::Keyed<T> >
inline Foam::List<Foam::Keyed<T>>
Foam::Keyed<T>::createList(const List<T>& lst, const labelUList& keys)
{
if (lst.size() != keys.size())
@ -101,7 +101,7 @@ Foam::Keyed<T>::createList(const List<T>& lst, const labelUList& keys)
<< abort(FatalError);
}
List<Keyed<T> > newList(lst.size());
List<Keyed<T>> newList(lst.size());
forAll(lst, elemI)
{

6
src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -73,7 +73,7 @@ public:
(
const UList<T>& posList,
const UList<T>& negList,
const Xfer<List<label> >&
const Xfer<List<label>>&
);
@ -101,7 +101,7 @@ public:
//- Reset addressing
inline void resetAddressing(const labelUList&);
inline void resetAddressing(const Xfer<List<label> >&);
inline void resetAddressing(const Xfer<List<label>>&);
// Member Operators

6
src/OpenFOAM/containers/Lists/BiIndirectList/BiIndirectListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ inline Foam::BiIndirectList<T>::BiIndirectList
(
const UList<T>& posList,
const UList<T>& negList,
const Xfer<List<label> >& addr
const Xfer<List<label>>& addr
)
:
posList_(const_cast<UList<T>&>(posList)),
@ -104,7 +104,7 @@ inline void Foam::BiIndirectList<T>::resetAddressing
template<class T>
inline void Foam::BiIndirectList<T>::resetAddressing
(
const Xfer<List<label> >& addr
const Xfer<List<label>>& addr
)
{
addressing_.transfer(addr());

4
src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -102,7 +102,7 @@ Foam::CompactListList<T, Container>::CompactListList
template<class T, class Container>
Foam::CompactListList<T, Container>::CompactListList
(
const Xfer<CompactListList<T, Container> >& lst
const Xfer<CompactListList<T, Container>>& lst
)
{
transfer(lst());

12
src/OpenFOAM/containers/Lists/CompactListList/CompactListList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -76,7 +76,7 @@ template<class T, class Container> Ostream& operator<<
Class CompactListList Declaration
\*---------------------------------------------------------------------------*/
template<class T, class Container = List<T> >
template<class T, class Container = List<T>>
class CompactListList
{
// Private data
@ -102,7 +102,7 @@ public:
//- Null constructor.
inline CompactListList();
//- Construct by converting given List<List<T> >
//- Construct by converting given List<List<T>>
explicit CompactListList(const List<Container>&);
//- Construct given size of offset table (number of rows)
@ -120,7 +120,7 @@ public:
CompactListList(const labelUList& rowSizes, const T&);
//- Construct by transferring the parameter contents
explicit CompactListList(const Xfer<CompactListList<T, Container> >&);
explicit CompactListList(const Xfer<CompactListList<T, Container>>&);
//- Construct as copy or re-use as specified.
CompactListList(CompactListList<T, Container>&, bool reUse);
@ -129,7 +129,7 @@ public:
CompactListList(Istream&);
//- Clone
inline autoPtr<CompactListList<T, Container> > clone() const;
inline autoPtr<CompactListList<T, Container>> clone() const;
// Member Functions
@ -194,7 +194,7 @@ public:
void transfer(CompactListList<T, Container>&);
//- Transfer the contents to the Xfer container
inline Xfer<CompactListList<T, Container> > xfer();
inline Xfer<CompactListList<T, Container>> xfer();
// Other

10
src/OpenFOAM/containers/Lists/CompactListList/CompactListListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -63,10 +63,10 @@ inline Foam::CompactListList<T, Container>::CompactListList
template<class T, class Container>
inline Foam::autoPtr<Foam::CompactListList<T, Container> >
inline Foam::autoPtr<Foam::CompactListList<T, Container>>
Foam::CompactListList<T, Container>::clone() const
{
return autoPtr<CompactListList<T, Container> >
return autoPtr<CompactListList<T, Container>>
(
new CompactListList<T, Container>(*this)
);
@ -79,7 +79,7 @@ template<class T, class Container>
inline const Foam::CompactListList<T, Container>&
Foam::CompactListList<T, Container>::null()
{
return NullObjectRef<CompactListList<T, Container> >();
return NullObjectRef<CompactListList<T, Container>>();
}
@ -165,7 +165,7 @@ inline Foam::label Foam::CompactListList<T, Container>::whichColumn
template<class T, class Container>
inline Foam::Xfer<Foam::CompactListList<T, Container> >
inline Foam::Xfer<Foam::CompactListList<T, Container>>
Foam::CompactListList<T, Container>::xfer()
{
return xferMove(*this);

8
src/OpenFOAM/containers/Lists/Distribution/Distribution.H
View File

@ -125,18 +125,18 @@ public:
//- Return the normalised distribution (probability density)
// and bins
List<List<Pair<scalar>> > normalised() const;
List<List<Pair<scalar>>> normalised() const;
//- Return the distribution of the total bin weights
List<List < Pair<scalar> > > raw() const;
List<List < Pair<scalar>>> raw() const;
//- Return the cumulative normalised distribution and
// integration locations (at end of bins)
List<List<Pair<scalar>> > cumulativeNormalised() const;
List<List<Pair<scalar>>> cumulativeNormalised() const;
//- Return the cumulative total bin weights and integration
// locations (at end of bins)
List<List<Pair<scalar>> > cumulativeRaw() const;
List<List<Pair<scalar>>> cumulativeRaw() const;
//- Resets the Distribution by clearing the stored lists.
// Leaves the same number of them and the same binWidth.

6
src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -115,7 +115,7 @@ public:
explicit inline DynamicList(const UIndirectList<T>&);
//- Construct by transferring the parameter contents
explicit inline DynamicList(const Xfer<List<T> >&);
explicit inline DynamicList(const Xfer<List<T>>&);
//- Construct from Istream. Size set to size of list read.
explicit DynamicList(Istream&);
@ -178,7 +178,7 @@ public:
inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
//- Transfer contents to the Xfer container as a plain List
inline Xfer<List<T> > xfer();
inline Xfer<List<T>> xfer();
// Member Operators

4
src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
View File

@ -85,7 +85,7 @@ inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
(
const Xfer<List<T> >& lst
const Xfer<List<T>>& lst
)
:
List<T>(lst),
@ -297,7 +297,7 @@ Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::Xfer<Foam::List<T> >
inline Foam::Xfer<Foam::List<T>>
Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::xfer()
{
return xferMoveTo<List<T>>(*this);

4
src/OpenFOAM/containers/Lists/FixedList/FixedList.H
View File

@ -83,7 +83,7 @@ public:
//- Hashing function class.
// Use Hasher directly for contiguous data. Otherwise hash incrementally.
template<class HashT=Hash<T> >
template<class HashT=Hash<T>>
class Hash
{
public:
@ -127,7 +127,7 @@ public:
FixedList(Istream&);
//- Clone
inline autoPtr<FixedList<T, Size> > clone() const;
inline autoPtr<FixedList<T, Size>> clone() const;
// Member Functions

6
src/OpenFOAM/containers/Lists/FixedList/FixedListI.H
View File

@ -95,10 +95,10 @@ inline Foam::FixedList<T, Size>::FixedList(const FixedList<T, Size>& lst)
template<class T, unsigned Size>
inline Foam::autoPtr<Foam::FixedList<T, Size> >
inline Foam::autoPtr<Foam::FixedList<T, Size>>
Foam::FixedList<T, Size>::clone() const
{
return autoPtr<FixedList<T, Size> >(new FixedList<T, Size>(*this));
return autoPtr<FixedList<T, Size>>(new FixedList<T, Size>(*this));
}
@ -107,7 +107,7 @@ Foam::FixedList<T, Size>::clone() const
template<class T, unsigned Size>
inline const Foam::FixedList<T, Size>& Foam::FixedList<T, Size>::null()
{
return NullObjectRef<FixedList<T, Size> >();
return NullObjectRef<FixedList<T, Size>>();
}

4
src/OpenFOAM/containers/Lists/FixedList/FixedListIO.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -54,7 +54,7 @@ Foam::Istream& Foam::operator>>(Foam::Istream& is, FixedList<T, Size>& L)
if (firstToken.isCompound())
{
L = dynamicCast<token::Compound<List<T> > >
L = dynamicCast<token::Compound<List<T>>>
(
firstToken.transferCompoundToken(is)
);

6
src/OpenFOAM/containers/Lists/IndirectList/IndirectList.H
View File

@ -76,7 +76,7 @@ protected:
explicit inline IndirectListAddressing(const labelUList& addr);
//- Construct by transferring addressing array
explicit inline IndirectListAddressing(const Xfer<List<label> >& addr);
explicit inline IndirectListAddressing(const Xfer<List<label>>& addr);
// Member Functions
@ -90,7 +90,7 @@ protected:
//- Reset addressing
inline void resetAddressing(const labelUList&);
inline void resetAddressing(const Xfer<List<label> >&);
inline void resetAddressing(const Xfer<List<label>>&);
};
@ -122,7 +122,7 @@ public:
inline IndirectList(const UList<T>&, const labelUList&);
//- Construct given the complete list and by transferring addressing
inline IndirectList(const UList<T>&, const Xfer<List<label> >&);
inline IndirectList(const UList<T>&, const Xfer<List<label>>&);
//- Copy constructor
inline IndirectList(const IndirectList<T>&);

8
src/OpenFOAM/containers/Lists/IndirectList/IndirectListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,7 @@ inline Foam::IndirectListAddressing::IndirectListAddressing
inline Foam::IndirectListAddressing::IndirectListAddressing
(
const Xfer<List<label> >& addr
const Xfer<List<label>>& addr
)
:
addressing_(addr)
@ -64,7 +64,7 @@ template<class T>
inline Foam::IndirectList<T>::IndirectList
(
const UList<T>& completeList,
const Xfer<List<label> >& addr
const Xfer<List<label>>& addr
)
:
IndirectListAddressing(addr),
@ -126,7 +126,7 @@ inline void Foam::IndirectListAddressing::resetAddressing
inline void Foam::IndirectListAddressing::resetAddressing
(
const Xfer<List<label> >& addr
const Xfer<List<label>>& addr
)
{
addressing_.transfer(addr());

4
src/OpenFOAM/containers/Lists/List/List.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -113,7 +113,7 @@ Foam::List<T>::List(const List<T>& a)
// Construct by transferring the parameter contents
template<class T>
Foam::List<T>::List(const Xfer<List<T> >& lst)
Foam::List<T>::List(const Xfer<List<T>>& lst)
{
transfer(lst());
}

8
src/OpenFOAM/containers/Lists/List/List.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -109,7 +109,7 @@ public:
List(const List<T>&);
//- Construct by transferring the parameter contents
List(const Xfer<List<T> >&);
List(const Xfer<List<T>>&);
//- Construct as copy or re-use as specified.
List(List<T>&, bool reUse);
@ -141,7 +141,7 @@ public:
List(Istream&);
//- Clone
inline autoPtr<List<T> > clone() const;
inline autoPtr<List<T>> clone() const;
//- Destructor
@ -200,7 +200,7 @@ public:
void transfer(SortableList<T>&);
//- Transfer contents to the Xfer container
inline Xfer<List<T> > xfer();
inline Xfer<List<T>> xfer();
//- Return subscript-checked element of UList.
inline T& newElmt(const label);

10
src/OpenFOAM/containers/Lists/List/ListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -31,9 +31,9 @@ inline Foam::List<T>::List()
template<class T>
inline Foam::autoPtr<Foam::List<T> > Foam::List<T>::clone() const
inline Foam::autoPtr<Foam::List<T>> Foam::List<T>::clone() const
{
return autoPtr<List<T> >(new List<T>(*this));
return autoPtr<List<T>>(new List<T>(*this));
}
@ -42,7 +42,7 @@ inline Foam::autoPtr<Foam::List<T> > Foam::List<T>::clone() const
template<class T>
inline const Foam::List<T>& Foam::List<T>::null()
{
return NullObjectRef<List<T> >();
return NullObjectRef<List<T>>();
}
@ -87,7 +87,7 @@ inline Foam::label Foam::List<T>::size() const
template<class T>
inline Foam::Xfer<Foam::List<T> > Foam::List<T>::xfer()
inline Foam::Xfer<Foam::List<T>> Foam::List<T>::xfer()
{
return xferMove(*this);
}

4
src/OpenFOAM/containers/Lists/List/ListIO.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -57,7 +57,7 @@ Foam::Istream& Foam::operator>>(Istream& is, List<T>& L)
{
L.transfer
(
dynamicCast<token::Compound<List<T> > >
dynamicCast<token::Compound<List<T>>>
(
firstToken.transferCompoundToken(is)
)

4
src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -112,7 +112,7 @@ public:
inline PackedBoolList(const Xfer<PackedBoolList>&);
//- Construct by transferring the parameter contents
inline PackedBoolList(const Xfer<PackedList<1> >&);
inline PackedBoolList(const Xfer<PackedList<1>>&);
//- Construct from a list of bools
explicit inline PackedBoolList(const Foam::UList<bool>&);

4
src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -67,7 +67,7 @@ inline Foam::PackedBoolList::PackedBoolList(const Xfer<PackedBoolList>& lst)
}
inline Foam::PackedBoolList::PackedBoolList(const Xfer<PackedList<1> >& lst)
inline Foam::PackedBoolList::PackedBoolList(const Xfer<PackedList<1>>& lst)
:
PackedList<1>(lst)
{}

4
src/OpenFOAM/containers/Lists/PackedList/PackedList.H
View File

@ -226,7 +226,7 @@ public:
inline PackedList(const PackedList<nBits>&);
//- Construct by transferring the parameter contents
inline PackedList(const Xfer<PackedList<nBits> >&);
inline PackedList(const Xfer<PackedList<nBits>>&);
//- Construct from a list of labels
explicit inline PackedList(const labelUList&);
@ -344,7 +344,7 @@ public:
inline void transfer(PackedList<nBits>&);
//- Transfer contents to the Xfer container
inline Xfer<PackedList<nBits> > xfer();
inline Xfer<PackedList<nBits>> xfer();
// IO

10
src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -222,7 +222,7 @@ inline Foam::PackedList<nBits>::PackedList(const PackedList<nBits>& lst)
template<unsigned nBits>
inline Foam::PackedList<nBits>::PackedList(const Xfer<PackedList<nBits> >& lst)
inline Foam::PackedList<nBits>::PackedList(const Xfer<PackedList<nBits>>& lst)
{
transfer(lst());
}
@ -257,10 +257,10 @@ inline Foam::PackedList<nBits>::PackedList(const UIndirectList<label>& lst)
template<unsigned nBits>
inline Foam::autoPtr<Foam::PackedList<nBits> >
inline Foam::autoPtr<Foam::PackedList<nBits>>
Foam::PackedList<nBits>::clone() const
{
return autoPtr<PackedList<nBits> >(new PackedList<nBits>(*this));
return autoPtr<PackedList<nBits>>(new PackedList<nBits>(*this));
}
@ -954,7 +954,7 @@ inline void Foam::PackedList<nBits>::transfer(PackedList<nBits>& lst)
template<unsigned nBits>
inline Foam::Xfer<Foam::PackedList<nBits> > Foam::PackedList<nBits>::xfer()
inline Foam::Xfer<Foam::PackedList<nBits>> Foam::PackedList<nBits>::xfer()
{
return xferMove(*this);
}

4
src/OpenFOAM/containers/Lists/PtrList/PtrList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -70,7 +70,7 @@ Foam::PtrList<T>::PtrList(const PtrList<T>& a, const CloneArg& cloneArg)
template<class T>
Foam::PtrList<T>::PtrList(const Xfer<PtrList<T> >& lst)
Foam::PtrList<T>::PtrList(const Xfer<PtrList<T>>& lst)
{
transfer(lst());
}

6
src/OpenFOAM/containers/Lists/PtrList/PtrList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -158,7 +158,7 @@ public:
PtrList(const PtrList<T>&, const CloneArg&);
//- Construct by transferring the parameter contents
PtrList(const Xfer<PtrList<T> >&);
PtrList(const Xfer<PtrList<T>>&);
//- Construct as copy or re-use as specified.
PtrList(PtrList<T>&, bool reUse);
@ -224,7 +224,7 @@ public:
void transfer(PtrList<T>&);
//- Transfer contents to the Xfer container
inline Xfer<PtrList<T> > xfer();
inline Xfer<PtrList<T>> xfer();
//- Is element set
inline bool set(const label) const;

4
src/OpenFOAM/containers/Lists/PtrList/PtrListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -142,7 +142,7 @@ inline Foam::autoPtr<T> Foam::PtrList<T>::set
template<class T>
inline Foam::Xfer<Foam::PtrList<T> > Foam::PtrList<T>::xfer()
inline Foam::Xfer<Foam::PtrList<T>> Foam::PtrList<T>::xfer()
{
return xferMove(*this);
}

8
src/OpenFOAM/containers/Lists/SortableList/SortableList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -42,7 +42,7 @@ Foam::SortableList<T>::SortableList(const UList<T>& values)
template<class T>
Foam::SortableList<T>::SortableList(const Xfer<List<T> >& values)
Foam::SortableList<T>::SortableList(const Xfer<List<T>>& values)
:
List<T>(values)
{
@ -122,9 +122,9 @@ void Foam::SortableList<T>::reverseSort()
template<class T>
Foam::Xfer<Foam::List<T> > Foam::SortableList<T>::xfer()
Foam::Xfer<Foam::List<T>> Foam::SortableList<T>::xfer()
{
return xferMoveTo<List<T> >(*this);
return xferMoveTo<List<T>>(*this);
}

6
src/OpenFOAM/containers/Lists/SortableList/SortableList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -71,7 +71,7 @@ public:
explicit SortableList(const UList<T>&);
//- Construct from transferred List, sorting immediately.
explicit SortableList(const Xfer<List<T> >&);
explicit SortableList(const Xfer<List<T>>&);
//- Construct given size. Sort later on.
// The indices remain empty until the list is sorted
@ -113,7 +113,7 @@ public:
void reverseSort();
//- Transfer contents to the Xfer container as a plain List
inline Xfer<List<T> > xfer();
inline Xfer<List<T>> xfer();
// Member Operators

2
src/OpenFOAM/containers/Lists/SubList/SubListI.H
View File

@ -74,7 +74,7 @@ inline Foam::SubList<T>::SubList
template<class T>
inline const Foam::SubList<T>& Foam::SubList<T>::null()
{
return NullObjectRef<SubList<T> >();
return NullObjectRef<SubList<T>>();
}

4
src/OpenFOAM/containers/Lists/UList/UListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ inline Foam::UList<T>::UList(T* __restrict__ v, label size)
template<class T>
inline const Foam::UList<T>& Foam::UList<T>::null()
{
return NullObjectRef<UList<T> >();
return NullObjectRef<UList<T>>();
}

4
src/OpenFOAM/containers/Lists/UList/UListIO.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -152,7 +152,7 @@ Foam::Istream& Foam::operator>>(Istream& is, UList<T>& L)
List<T> elems;
elems.transfer
(
dynamicCast<token::Compound<List<T> > >
dynamicCast<token::Compound<List<T>>>
(
firstToken.transferCompoundToken(is)
)

4
src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,7 +44,7 @@ Foam::UPtrList<T>::UPtrList(const label s)
template<class T>
Foam::UPtrList<T>::UPtrList(const Xfer<UPtrList<T> >& lst)
Foam::UPtrList<T>::UPtrList(const Xfer<UPtrList<T>>& lst)
{
transfer(lst());
}

6
src/OpenFOAM/containers/Lists/UPtrList/UPtrList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -110,7 +110,7 @@ public:
explicit UPtrList(const label);
//- Construct by transferring the parameter contents
UPtrList(const Xfer<UPtrList<T> >&);
UPtrList(const Xfer<UPtrList<T>>&);
//- Construct as copy or re-use as specified.
UPtrList(UPtrList<T>&, bool reUse);
@ -159,7 +159,7 @@ public:
void transfer(UPtrList<T>&);
//- Transfer contents to the Xfer container
inline Xfer<UPtrList<T> > xfer();
inline Xfer<UPtrList<T>> xfer();
//- Is element set
inline bool set(const label) const;

4
src/OpenFOAM/containers/Lists/UPtrList/UPtrListI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -93,7 +93,7 @@ inline T* Foam::UPtrList<T>::set(const label i, T* ptr)
template<class T>
inline Foam::Xfer<Foam::UPtrList<T> > Foam::UPtrList<T>::xfer()
inline Foam::Xfer<Foam::UPtrList<T>> Foam::UPtrList<T>::xfer()
{
return xferMove(*this);
}

4
src/OpenFOAM/db/IOobjects/CompactIOField/CompactIOField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -127,7 +127,7 @@ template<class T, class BaseType>
Foam::CompactIOField<T, BaseType>::CompactIOField
(
const IOobject& io,
const Xfer<Field<T> >& list
const Xfer<Field<T>>& list
)
:
regIOobject(io)

4
src/OpenFOAM/db/IOobjects/CompactIOField/CompactIOField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -95,7 +95,7 @@ public:
CompactIOField(const IOobject&, const Field<T>&);
//- Construct by transferring the Field contents
CompactIOField(const IOobject&, const Xfer<Field<T> >&);
CompactIOField(const IOobject&, const Xfer<Field<T>>&);
// Destructor

4
src/OpenFOAM/db/IOobjects/CompactIOList/CompactIOList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -127,7 +127,7 @@ template<class T, class BaseType>
Foam::CompactIOList<T, BaseType>::CompactIOList
(
const IOobject& io,
const Xfer<List<T> >& list
const Xfer<List<T>>& list
)
:
regIOobject(io)

4
src/OpenFOAM/db/IOobjects/CompactIOList/CompactIOList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -97,7 +97,7 @@ public:
CompactIOList(const IOobject&, const List<T>&);
//- Construct by transferring the List contents
CompactIOList(const IOobject&, const Xfer<List<T> >&);
CompactIOList(const IOobject&, const Xfer<List<T>>&);
// Destructor

4
src/OpenFOAM/db/IOobjects/IOField/IOField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -126,7 +126,7 @@ Foam::IOField<Type>::IOField(const IOobject& io, const Field<Type>& f)
template<class Type>
Foam::IOField<Type>::IOField(const IOobject& io, const Xfer<Field<Type> >& f)
Foam::IOField<Type>::IOField(const IOobject& io, const Xfer<Field<Type>>& f)
:
regIOobject(io)
{

4
src/OpenFOAM/db/IOobjects/IOField/IOField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -71,7 +71,7 @@ public:
IOField(const IOobject&, const Field<Type>&);
//- Construct by transferring the Field contents
IOField(const IOobject&, const Xfer<Field<Type> >&);
IOField(const IOobject&, const Xfer<Field<Type>>&);
//- Destructor

4
src/OpenFOAM/db/IOobjects/IOList/IOList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -124,7 +124,7 @@ Foam::IOList<T>::IOList(const IOobject& io, const List<T>& list)
template<class T>
Foam::IOList<T>::IOList(const IOobject& io, const Xfer<List<T> >& list)
Foam::IOList<T>::IOList(const IOobject& io, const Xfer<List<T>>& list)
:
regIOobject(io)
{

4
src/OpenFOAM/db/IOobjects/IOList/IOList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -72,7 +72,7 @@ public:
IOList(const IOobject&, const List<T>&);
//- Construct by transferring the List contents
IOList(const IOobject&, const Xfer<List<T> >&);
IOList(const IOobject&, const Xfer<List<T>>&);
//- Destructor

4
src/OpenFOAM/db/IOobjects/IOMap/IOMap.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -95,7 +95,7 @@ Foam::IOMap<T>::IOMap(const IOobject& io, const Map<T>& map)
template<class T>
Foam::IOMap<T>::IOMap(const IOobject& io, const Xfer<Map<T> >& map)
Foam::IOMap<T>::IOMap(const IOobject& io, const Xfer<Map<T>>& map)
:
regIOobject(io)
{

4
src/OpenFOAM/db/IOobjects/IOMap/IOMap.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -72,7 +72,7 @@ public:
IOMap(const IOobject&, const Map<T>&);
//- Construct by transferring the Map contents
IOMap(const IOobject&, const Xfer<Map<T> >&);
IOMap(const IOobject&, const Xfer<Map<T>>&);
//- Destructor

4
src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -108,7 +108,7 @@ Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const PtrList<T>& list)
template<class T>
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const Xfer<PtrList<T> >& list)
Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const Xfer<PtrList<T>>& list)
:
regIOobject(io)
{

4
src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -76,7 +76,7 @@ public:
IOPtrList(const IOobject&, const PtrList<T>&);
//- Construct by transferring the PtrList contents
IOPtrList(const IOobject&, const Xfer<PtrList<T> >&);
IOPtrList(const IOobject&, const Xfer<PtrList<T>>&);
//- Destructor

6
src/OpenFOAM/db/IOstreams/Pstreams/PstreamBuffers.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -102,10 +102,10 @@ class PstreamBuffers
const IOstream::versionNumber version_;
//- Send buffer
List<DynamicList<char> > sendBuf_;
List<DynamicList<char>> sendBuf_;
//- Receive buffer
List<DynamicList<char> > recvBuf_;
List<DynamicList<char>> recvBuf_;
//- Read position in recvBuf_
labelList recvBufPos_;

14
src/OpenFOAM/db/IOstreams/Pstreams/UPstream.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -119,7 +119,7 @@ Foam::List<Foam::UPstream::commsStruct> Foam::UPstream::calcLinearComm
void Foam::UPstream::collectReceives
(
const label procID,
const List<DynamicList<label> >& receives,
const List<DynamicList<label>>& receives,
DynamicList<label>& allReceives
)
{
@ -170,7 +170,7 @@ Foam::List<Foam::UPstream::commsStruct> Foam::UPstream::calcTreeComm
nLevels++;
}
List<DynamicList<label> > receives(nProcs);
List<DynamicList<label>> receives(nProcs);
labelList sends(nProcs, -1);
// Info<< "Using " << nLevels << " communication levels" << endl;
@ -201,7 +201,7 @@ Foam::List<Foam::UPstream::commsStruct> Foam::UPstream::calcTreeComm
// For all processors find the processors it receives data from
// (and the processors they receive data from etc.)
List<DynamicList<label> > allReceives(nProcs);
List<DynamicList<label>> allReceives(nProcs);
for (label procID = 0; procID < nProcs; procID++)
{
collectReceives(procID, receives, allReceives[procID]);
@ -388,7 +388,7 @@ Foam::LIFOStack<Foam::label> Foam::UPstream::freeComms_;
Foam::DynamicList<int> Foam::UPstream::myProcNo_(10);
// List of process IDs
Foam::DynamicList<Foam::List<int> > Foam::UPstream::procIDs_(10);
Foam::DynamicList<Foam::List<int>> Foam::UPstream::procIDs_(10);
// Parent communicator
Foam::DynamicList<Foam::label> Foam::UPstream::parentCommunicator_(10);
@ -397,11 +397,11 @@ Foam::DynamicList<Foam::label> Foam::UPstream::parentCommunicator_(10);
int Foam::UPstream::msgType_(1);
// Linear communication schedule
Foam::DynamicList<Foam::List<Foam::UPstream::commsStruct> >
Foam::DynamicList<Foam::List<Foam::UPstream::commsStruct>>
Foam::UPstream::linearCommunication_(10);
// Multi level communication schedule
Foam::DynamicList<Foam::List<Foam::UPstream::commsStruct> >
Foam::DynamicList<Foam::List<Foam::UPstream::commsStruct>>
Foam::UPstream::treeCommunication_(10);

10
src/OpenFOAM/db/IOstreams/Pstreams/UPstream.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -188,11 +188,11 @@ private:
static LIFOStack<label> freeComms_;
static DynamicList<int> myProcNo_;
static DynamicList<List<int> > procIDs_;
static DynamicList<List<int>> procIDs_;
static DynamicList<label> parentCommunicator_;
static DynamicList<List<commsStruct> > linearCommunication_;
static DynamicList<List<commsStruct> > treeCommunication_;
static DynamicList<List<commsStruct>> linearCommunication_;
static DynamicList<List<commsStruct>> treeCommunication_;
// Private Member Functions
@ -211,7 +211,7 @@ private:
static void collectReceives
(
const label procID,
const List<DynamicList<label> >& receives,
const List<DynamicList<label>>& receives,
DynamicList<label>& allReceives
);

4
src/OpenFOAM/db/IOstreams/Tstreams/ITstream.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -88,7 +88,7 @@ public:
ITstream
(
const string& name,
const Xfer<List<token> >& tokens,
const Xfer<List<token>>& tokens,
streamFormat format=ASCII,
versionNumber version=currentVersion
)

4
src/OpenFOAM/db/IOstreams/token/token.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -444,7 +444,7 @@ Ostream& operator<<(Ostream& os, const InfoProxy<token>& ip);
defineTemplateTypeNameAndDebugWithName(token::Compound<Type>, #Type, 0);
#define addCompoundToRunTimeSelectionTable(Type, Name) \
token::compound::addIstreamConstructorToTable<token::Compound<Type> > \
token::compound::addIstreamConstructorToTable<token::Compound<Type>> \
add##Name##IstreamConstructorToTable_;

16
src/OpenFOAM/db/dictionary/dictionary.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,7 +51,7 @@ bool Foam::dictionary::findInPatterns
const bool patternMatch,
const word& Keyword,
DLList<entry*>::const_iterator& wcLink,
DLList<autoPtr<regExp> >::const_iterator& reLink
DLList<autoPtr<regExp>>::const_iterator& reLink
) const
{
if (patternEntries_.size())
@ -82,7 +82,7 @@ bool Foam::dictionary::findInPatterns
const bool patternMatch,
const word& Keyword,
DLList<entry*>::iterator& wcLink,
DLList<autoPtr<regExp> >::iterator& reLink
DLList<autoPtr<regExp>>::iterator& reLink
)
{
if (patternEntries_.size())
@ -319,7 +319,7 @@ bool Foam::dictionary::found
{
DLList<entry*>::const_iterator wcLink =
patternEntries_.begin();
DLList<autoPtr<regExp> >::const_iterator reLink =
DLList<autoPtr<regExp>>::const_iterator reLink =
patternRegexps_.begin();
// Find in patterns using regular expressions only
@ -356,7 +356,7 @@ const Foam::entry* Foam::dictionary::lookupEntryPtr
{
DLList<entry*>::const_iterator wcLink =
patternEntries_.begin();
DLList<autoPtr<regExp> >::const_iterator reLink =
DLList<autoPtr<regExp>>::const_iterator reLink =
patternRegexps_.begin();
// Find in patterns using regular expressions only
@ -395,7 +395,7 @@ Foam::entry* Foam::dictionary::lookupEntryPtr
{
DLList<entry*>::iterator wcLink =
patternEntries_.begin();
DLList<autoPtr<regExp> >::iterator reLink =
DLList<autoPtr<regExp>>::iterator reLink =
patternRegexps_.begin();
// Find in patterns using regular expressions only
@ -889,7 +889,7 @@ bool Foam::dictionary::remove(const word& Keyword)
// Delete from patterns first
DLList<entry*>::iterator wcLink =
patternEntries_.begin();
DLList<autoPtr<regExp> >::iterator reLink =
DLList<autoPtr<regExp>>::iterator reLink =
patternRegexps_.begin();
// Find in pattern using exact match only
@ -957,7 +957,7 @@ bool Foam::dictionary::changeKeyword
// Delete from patterns first
DLList<entry*>::iterator wcLink =
patternEntries_.begin();
DLList<autoPtr<regExp> >::iterator reLink =
DLList<autoPtr<regExp>>::iterator reLink =
patternRegexps_.begin();
// Find in patterns using exact match only

8
src/OpenFOAM/db/dictionary/dictionary.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -156,7 +156,7 @@ class dictionary
DLList<entry*> patternEntries_;
//- Patterns as precompiled regular expressions
DLList<autoPtr<regExp> > patternRegexps_;
DLList<autoPtr<regExp>> patternRegexps_;
// Private Member Functions
@ -167,7 +167,7 @@ class dictionary
const bool patternMatch,
const word& Keyword,
DLList<entry*>::const_iterator& wcLink,
DLList<autoPtr<regExp> >::const_iterator& reLink
DLList<autoPtr<regExp>>::const_iterator& reLink
) const;
//- Search patterns table for exact match or regular expression match
@ -176,7 +176,7 @@ class dictionary
const bool patternMatch,
const word& Keyword,
DLList<entry*>::iterator& wcLink,
DLList<autoPtr<regExp> >::iterator& reLink
DLList<autoPtr<regExp>>::iterator& reLink
);

4
src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -136,7 +136,7 @@ Foam::primitiveEntry::primitiveEntry
Foam::primitiveEntry::primitiveEntry
(
const keyType& key,
const Xfer<List<token> >& tokens
const Xfer<List<token>>& tokens
)
:
entry(key),

4
src/OpenFOAM/db/dictionary/primitiveEntry/primitiveEntry.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -113,7 +113,7 @@ public:
primitiveEntry(const keyType&, const UList<token>&);
//- Construct from keyword and by transferring a list of tokens
primitiveEntry(const keyType&, const Xfer<List<token> >&);
primitiveEntry(const keyType&, const Xfer<List<token>>&);
//- Construct from keyword and a T
template<class T>

14
src/OpenFOAM/db/runTimeSelection/memberFunctions/addToMemberFunctionSelectionTable.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -65,7 +65,7 @@ Description
\
/* Add the thisType memberFunction to the table */ \
baseType::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add##thisType##Targ##memberFunction##argNames##MemberFunctionTo## \
baseType##Table_
@ -77,7 +77,7 @@ Description
\
/* Add the thisType memberFunction to the table, find by lookup name */ \
baseType::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add_##lookup##_##thisType##Targ##memberFunction##argNames## \
MemberFunctionTo##baseType##Table_(#lookup)
@ -87,7 +87,7 @@ Description
\
/* Add the thisType memberFunction to the table */ \
baseType<Targ>::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add##thisType##Targ##memberFunction##argNames##MemberFunctionTo## \
baseType##Targ##Table_
@ -97,7 +97,7 @@ Description
\
/* Add the thisType memberFunction to the table, find by lookup name */ \
baseType<Targ>::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add_##lookup##_##thisType##Targ##memberFunction##argNames## \
MemberFunctionTo##baseType##Targ##Table_(#lookup)
@ -112,7 +112,7 @@ Description
\
/* Add the thisType memberFunction to the table */ \
baseType<Targ>::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add##thisType##Targ##memberFunction##argNames##MemberFunctionTo## \
baseType##Targ##Table_
@ -124,7 +124,7 @@ Description
\
/* Add the thisType memberFunction to the table, find by lookup name */ \
baseType<Targ>::add##memberFunction##argNames## \
MemberFunctionToTable<thisType<Targ> > \
MemberFunctionToTable<thisType<Targ>> \
add_##lookup##_##thisType##Targ##memberFunction##argNames## \
MemberFunctionTo##baseType##Targ##Table_(#lookup)

26
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -144,7 +144,7 @@ DimensionedField<Type, GeoMesh>::DimensionedField
template<class Type, class GeoMesh>
DimensionedField<Type, GeoMesh>::DimensionedField
(
const Xfer<DimensionedField<Type, GeoMesh> >& df
const Xfer<DimensionedField<Type, GeoMesh>>& df
)
:
regIOobject(df(), true),
@ -158,7 +158,7 @@ DimensionedField<Type, GeoMesh>::DimensionedField
template<class Type, class GeoMesh>
DimensionedField<Type, GeoMesh>::DimensionedField
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
:
regIOobject(tdf(), tdf.isTmp()),
@ -237,7 +237,7 @@ template<class Type, class GeoMesh>
DimensionedField<Type, GeoMesh>::DimensionedField
(
const word& newName,
const Xfer<DimensionedField<Type, GeoMesh> >& df
const Xfer<DimensionedField<Type, GeoMesh>>& df
)
:
regIOobject(newName, df, true),
@ -252,7 +252,7 @@ template<class Type, class GeoMesh>
DimensionedField<Type, GeoMesh>::DimensionedField
(
const word& newName,
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
:
regIOobject(newName, tdf(), true),
@ -270,10 +270,10 @@ DimensionedField<Type, GeoMesh>::DimensionedField
template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh> >
tmp<DimensionedField<Type, GeoMesh>>
DimensionedField<Type, GeoMesh>::clone() const
{
return tmp<DimensionedField<Type, GeoMesh> >
return tmp<DimensionedField<Type, GeoMesh>>
(
new DimensionedField<Type, GeoMesh>(*this)
);
@ -300,7 +300,7 @@ DimensionedField<Type, GeoMesh>::component
const direction d
) const
{
tmp<DimensionedField<cmptType, GeoMesh> > result
tmp<DimensionedField<cmptType, GeoMesh>> result
(
new DimensionedField<cmptType, GeoMesh>
(
@ -350,10 +350,10 @@ void DimensionedField<Type, GeoMesh>::replace
template<class Type, class GeoMesh>
tmp<DimensionedField<Type, GeoMesh> >
tmp<DimensionedField<Type, GeoMesh>>
DimensionedField<Type, GeoMesh>::T() const
{
tmp<DimensionedField<Type, GeoMesh> > result
tmp<DimensionedField<Type, GeoMesh>> result
(
new DimensionedField<Type, GeoMesh>
(
@ -409,7 +409,7 @@ dimensioned<Type> DimensionedField<Type, GeoMesh>::weightedAverage
template<class Type, class GeoMesh>
dimensioned<Type> DimensionedField<Type, GeoMesh>::weightedAverage
(
const tmp<DimensionedField<scalar, GeoMesh> >& tweightField
const tmp<DimensionedField<scalar, GeoMesh>>& tweightField
) const
{
dimensioned<Type> wa = weightedAverage(tweightField());
@ -444,7 +444,7 @@ void DimensionedField<Type, GeoMesh>::operator=
template<class Type, class GeoMesh>
void DimensionedField<Type, GeoMesh>::operator=
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
{
const DimensionedField<Type, GeoMesh>& df = tdf();
@ -493,7 +493,7 @@ void DimensionedField<Type, GeoMesh>::operator op \
template<class Type, class GeoMesh> \
void DimensionedField<Type, GeoMesh>::operator op \
( \
const tmp<DimensionedField<TYPE, GeoMesh> >& tdf \
const tmp<DimensionedField<TYPE, GeoMesh>>& tdf \
) \
{ \
operator op(tdf()); \

34
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -60,7 +60,7 @@ template<class Type, class GeoMesh> Ostream& operator<<
template<class Type, class GeoMesh> Ostream& operator<<
(
Ostream&,
const tmp<DimensionedField<Type, GeoMesh> >&
const tmp<DimensionedField<Type, GeoMesh>>&
);
@ -165,14 +165,14 @@ public:
//- Construct by transferring the DimensionedField
DimensionedField
(
const Xfer<DimensionedField<Type, GeoMesh> >&
const Xfer<DimensionedField<Type, GeoMesh>>&
);
//- Construct as copy of tmp<DimensionedField> deleting argument
#ifndef NoConstructFromTmp
DimensionedField
(
const tmp<DimensionedField<Type, GeoMesh> >&
const tmp<DimensionedField<Type, GeoMesh>>&
);
#endif
@ -210,7 +210,7 @@ public:
DimensionedField
(
const word& newName,
const Xfer<DimensionedField<Type, GeoMesh> >&
const Xfer<DimensionedField<Type, GeoMesh>>&
);
//- Construct as copy resetting name
@ -218,12 +218,12 @@ public:
DimensionedField
(
const word& newName,
const tmp<DimensionedField<Type, GeoMesh> >&
const tmp<DimensionedField<Type, GeoMesh>>&
);
#endif
//- Clone
tmp<DimensionedField<Type, GeoMesh> > clone() const;
tmp<DimensionedField<Type, GeoMesh>> clone() const;
//- Destructor
@ -252,7 +252,7 @@ public:
inline Field<Type>& field();
//- Return a component field of the field
tmp<DimensionedField<cmptType, GeoMesh> > component
tmp<DimensionedField<cmptType, GeoMesh>> component
(
const direction
) const;
@ -268,11 +268,11 @@ public:
void replace
(
const direction,
const tmp<DimensionedField<cmptType, GeoMesh> >&
const tmp<DimensionedField<cmptType, GeoMesh>>&
);
//- Return the field transpose (only defined for second rank tensors)
tmp<DimensionedField<Type, GeoMesh> > T() const;
tmp<DimensionedField<Type, GeoMesh>> T() const;
//- Calculate and return arithmetic average
dimensioned<Type> average() const;
@ -286,7 +286,7 @@ public:
//- Calculate and return weighted average
dimensioned<Type> weightedAverage
(
const tmp<DimensionedField<scalar, GeoMesh> >&
const tmp<DimensionedField<scalar, GeoMesh>>&
) const;
@ -300,20 +300,20 @@ public:
// Member Operators
void operator=(const DimensionedField<Type, GeoMesh>&);
void operator=(const tmp<DimensionedField<Type, GeoMesh> >&);
void operator=(const tmp<DimensionedField<Type, GeoMesh>>&);
void operator=(const dimensioned<Type>&);
void operator+=(const DimensionedField<Type, GeoMesh>&);
void operator+=(const tmp<DimensionedField<Type, GeoMesh> >&);
void operator+=(const tmp<DimensionedField<Type, GeoMesh>>&);
void operator-=(const DimensionedField<Type, GeoMesh>&);
void operator-=(const tmp<DimensionedField<Type, GeoMesh> >&);
void operator-=(const tmp<DimensionedField<Type, GeoMesh>>&);
void operator*=(const DimensionedField<scalar, GeoMesh>&);
void operator*=(const tmp<DimensionedField<scalar, GeoMesh> >&);
void operator*=(const tmp<DimensionedField<scalar, GeoMesh>>&);
void operator/=(const DimensionedField<scalar, GeoMesh>&);
void operator/=(const tmp<DimensionedField<scalar, GeoMesh> >&);
void operator/=(const tmp<DimensionedField<scalar, GeoMesh>>&);
void operator+=(const dimensioned<Type>&);
void operator-=(const dimensioned<Type>&);
@ -333,7 +333,7 @@ public:
friend Ostream& operator<< <Type, GeoMesh>
(
Ostream&,
const tmp<DimensionedField<Type, GeoMesh> >&
const tmp<DimensionedField<Type, GeoMesh>>&
);
};

106
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,7 +36,7 @@ namespace Foam
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
template<class Type, class GeoMesh, int r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh> >
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const DimensionedField<Type, GeoMesh>& df,
@ -45,7 +45,7 @@ pow
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<DimensionedField<powProductType, GeoMesh> > tPow
tmp<DimensionedField<powProductType, GeoMesh>> tPow
(
new DimensionedField<powProductType, GeoMesh>
(
@ -67,10 +67,10 @@ pow
template<class Type, class GeoMesh, int r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh> >
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf,
const tmp<DimensionedField<Type, GeoMesh>>& tdf,
typename powProduct<Type, r>::type
)
{
@ -78,7 +78,7 @@ pow
const DimensionedField<Type, GeoMesh>& df = tdf();
tmp<DimensionedField<powProductType, GeoMesh> > tPow =
tmp<DimensionedField<powProductType, GeoMesh>> tPow =
reuseTmpDimensionedField<powProductType, Type, GeoMesh>::New
(
tdf,
@ -94,12 +94,12 @@ pow
}
template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh> >
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const DimensionedField<Type, GeoMesh>& df)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<DimensionedField<outerProductType, GeoMesh> > tSqr
tmp<DimensionedField<outerProductType, GeoMesh>> tSqr
(
new DimensionedField<outerProductType, GeoMesh>
(
@ -120,14 +120,14 @@ sqr(const DimensionedField<Type, GeoMesh>& df)
}
template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh> >
sqr(const tmp<DimensionedField<Type, GeoMesh> >& tdf)
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
const DimensionedField<Type, GeoMesh>& df = tdf();
tmp<DimensionedField<outerProductType, GeoMesh> > tSqr =
tmp<DimensionedField<outerProductType, GeoMesh>> tSqr =
reuseTmpDimensionedField<outerProductType, Type, GeoMesh>::New
(
tdf,
@ -144,12 +144,12 @@ sqr(const tmp<DimensionedField<Type, GeoMesh> >& tdf)
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > magSqr
tmp<DimensionedField<scalar, GeoMesh>> magSqr
(
const DimensionedField<Type, GeoMesh>& df
)
{
tmp<DimensionedField<scalar, GeoMesh> > tMagSqr
tmp<DimensionedField<scalar, GeoMesh>> tMagSqr
(
new DimensionedField<scalar, GeoMesh>
(
@ -170,14 +170,14 @@ tmp<DimensionedField<scalar, GeoMesh> > magSqr
}
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > magSqr
tmp<DimensionedField<scalar, GeoMesh>> magSqr
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
{
const DimensionedField<Type, GeoMesh>& df = tdf();
tmp<DimensionedField<scalar, GeoMesh> > tMagSqr =
tmp<DimensionedField<scalar, GeoMesh>> tMagSqr =
reuseTmpDimensionedField<scalar, Type, GeoMesh>::New
(
tdf,
@ -194,12 +194,12 @@ tmp<DimensionedField<scalar, GeoMesh> > magSqr
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > mag
tmp<DimensionedField<scalar, GeoMesh>> mag
(
const DimensionedField<Type, GeoMesh>& df
)
{
tmp<DimensionedField<scalar, GeoMesh> > tMag
tmp<DimensionedField<scalar, GeoMesh>> tMag
(
new DimensionedField<scalar, GeoMesh>
(
@ -220,14 +220,14 @@ tmp<DimensionedField<scalar, GeoMesh> > mag
}
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > mag
tmp<DimensionedField<scalar, GeoMesh>> mag
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
{
const DimensionedField<Type, GeoMesh>& df = tdf();
tmp<DimensionedField<scalar, GeoMesh> > tMag =
tmp<DimensionedField<scalar, GeoMesh>> tMag =
reuseTmpDimensionedField<scalar, Type, GeoMesh>::New
(
tdf,
@ -253,7 +253,7 @@ cmptAv(const DimensionedField<Type, GeoMesh>& df)
{
typedef typename DimensionedField<Type, GeoMesh>::cmptType cmptType;
tmp<DimensionedField<cmptType, GeoMesh> > CmptAv
tmp<DimensionedField<cmptType, GeoMesh>> CmptAv
(
new DimensionedField<scalar, GeoMesh>
(
@ -279,14 +279,14 @@ tmp
DimensionedField
<typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
>
cmptAv(const tmp<DimensionedField<Type, GeoMesh> >& tdf)
cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf)
{
typedef typename DimensionedField<Type, GeoMesh>::cmptType
cmptType;
const DimensionedField<Type, GeoMesh>& df = tdf();
tmp<DimensionedField<cmptType, GeoMesh> > CmptAv =
tmp<DimensionedField<cmptType, GeoMesh>> CmptAv =
reuseTmpDimensionedField<cmptType, Type, GeoMesh>::New
(
tdf,
@ -320,7 +320,7 @@ dimensioned<returnType> func \
template<class Type, class GeoMesh> \
dimensioned<returnType> func \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
) \
{ \
dimensioned<returnType> res = func(tdf1()); \
@ -367,7 +367,7 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
@ -375,7 +375,7 @@ operator op \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<DimensionedField<productType, GeoMesh> > tRes \
tmp<DimensionedField<productType, GeoMesh>> tRes \
( \
new DimensionedField<productType, GeoMesh> \
( \
@ -396,18 +396,18 @@ operator op \
} \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
\
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<productType, GeoMesh> > tRes = \
tmp<DimensionedField<productType, GeoMesh>> tRes = \
reuseTmpDimensionedField<productType, Type2, GeoMesh>::New \
( \
tdf2, \
@ -423,10 +423,10 @@ operator op \
} \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
@ -434,7 +434,7 @@ operator op \
\
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<productType, GeoMesh> > tRes = \
tmp<DimensionedField<productType, GeoMesh>> tRes = \
reuseTmpDimensionedField<productType, Type1, GeoMesh>::New \
( \
tdf1, \
@ -450,11 +450,11 @@ operator op \
} \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
@ -462,7 +462,7 @@ operator op \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<productType, GeoMesh> > tRes = \
tmp<DimensionedField<productType, GeoMesh>> tRes = \
reuseTmpTmpDimensionedField \
<productType, Type1, Type1, Type2, GeoMesh>::New \
( \
@ -481,7 +481,7 @@ operator op \
} \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type, GeoMesh>& df1, \
@ -490,7 +490,7 @@ operator op \
{ \
typedef typename product<Type, Form>::type productType; \
\
tmp<DimensionedField<productType, GeoMesh> > tRes \
tmp<DimensionedField<productType, GeoMesh>> tRes \
( \
new DimensionedField<productType, GeoMesh> \
( \
@ -511,7 +511,7 @@ operator op \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type, GeoMesh>& df1, \
@ -523,10 +523,10 @@ operator op \
\
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \
const dimensioned<Form>& dvs \
) \
{ \
@ -534,7 +534,7 @@ operator op \
\
const DimensionedField<Type, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<productType, GeoMesh> > tRes = \
tmp<DimensionedField<productType, GeoMesh>> tRes = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \
( \
tdf1, \
@ -550,10 +550,10 @@ operator op \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
@ -562,7 +562,7 @@ operator op \
\
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
@ -570,7 +570,7 @@ operator op \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<DimensionedField<productType, GeoMesh> > tRes \
tmp<DimensionedField<productType, GeoMesh>> tRes \
( \
new DimensionedField<productType, GeoMesh> \
( \
@ -591,7 +591,7 @@ operator op \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
@ -602,18 +602,18 @@ operator op \
} \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
\
const DimensionedField<Type, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<productType, GeoMesh> > tRes = \
tmp<DimensionedField<productType, GeoMesh>> tRes = \
reuseTmpDimensionedField<productType, Type, GeoMesh>::New \
( \
tdf1, \
@ -629,11 +629,11 @@ operator op \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
) \
{ \
return dimensioned<Form>(static_cast<const Form&>(vs)) op tdf1; \

70
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,7 +36,7 @@ namespace Foam
// * * * * * * * * * * * * * * * Global functions * * * * * * * * * * * * * //
template<class Type, class GeoMesh, int r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh> >
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const DimensionedField<Type, GeoMesh>& df,
@ -44,43 +44,43 @@ pow
);
template<class Type, class GeoMesh, int r>
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh> >
tmp<DimensionedField<typename powProduct<Type, r>::type, GeoMesh>>
pow
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf,
const tmp<DimensionedField<Type, GeoMesh>>& tdf,
typename powProduct<Type, r>::type
);
template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh> >
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const DimensionedField<Type, GeoMesh>& df);
template<class Type, class GeoMesh>
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh> >
sqr(const tmp<DimensionedField<Type, GeoMesh> >& tdf);
tmp<DimensionedField<typename outerProduct<Type, Type>::type, GeoMesh>>
sqr(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > magSqr
tmp<DimensionedField<scalar, GeoMesh>> magSqr
(
const DimensionedField<Type, GeoMesh>& df
);
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > magSqr
tmp<DimensionedField<scalar, GeoMesh>> magSqr
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
);
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > mag
tmp<DimensionedField<scalar, GeoMesh>> mag
(
const DimensionedField<Type, GeoMesh>& df
);
template<class Type, class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > mag
tmp<DimensionedField<scalar, GeoMesh>> mag
(
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
);
template<class Type, class GeoMesh>
@ -97,7 +97,7 @@ tmp
DimensionedField
<typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
>
cmptAv(const tmp<DimensionedField<Type, GeoMesh> >& tdf);
cmptAv(const tmp<DimensionedField<Type, GeoMesh>>& tdf);
#define UNARY_REDUCTION_FUNCTION(returnType, func, dfunc) \
@ -110,7 +110,7 @@ dimensioned<returnType> func \
template<class Type, class GeoMesh> \
dimensioned<returnType> func \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
);
UNARY_REDUCTION_FUNCTION(Type, max, gMax)
@ -152,7 +152,7 @@ BINARY_TYPE_OPERATOR_FS(Type, Type, scalar, /, '|', divide)
#define PRODUCT_OPERATOR(product, op, opFunc) \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
@ -160,31 +160,31 @@ operator op \
); \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
template<class Type1, class Type2, class GeoMesh> \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type1, Type2>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type, GeoMesh>& df1, \
@ -192,7 +192,7 @@ operator op \
); \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const DimensionedField<Type, GeoMesh>& df1, \
@ -200,23 +200,23 @@ operator op \
); \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Type, Form>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \
const dimensioned<Form>& dvs \
); \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
@ -224,7 +224,7 @@ operator op \
); \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
@ -232,19 +232,19 @@ operator op \
); \
\
template<class Form, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const dimensioned<Form>& dvs, \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
); \
\
template<class Form, class Cmpt, int nCmpt, class Type, class GeoMesh> \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh> > \
tmp<DimensionedField<typename product<Form, Type>::type, GeoMesh>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<DimensionedField<Type, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type, GeoMesh>>& tdf1 \
);
PRODUCT_OPERATOR(typeOfSum, +, add)

134
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,12 +30,12 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -56,14 +56,14 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -86,12 +86,12 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define UNARY_OPERATOR(ReturnType, Type1, Op, OpFunc, Dfunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -112,14 +112,14 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -142,13 +142,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -169,15 +169,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
@ -195,15 +195,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -221,16 +221,16 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpTmpDimensionedField \
<ReturnType, Type1, Type1, Type2, GeoMesh>::New \
@ -256,13 +256,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -283,7 +283,7 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
@ -294,15 +294,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
@ -320,10 +320,10 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
return Func(dimensioned<Type2>(t1), tdf2); \
@ -333,13 +333,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const dimensioned<Type2>& dt2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -360,7 +360,7 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
@ -371,15 +371,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -397,9 +397,9 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
) \
{ \
@ -417,13 +417,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -444,15 +444,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
@ -470,15 +470,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -496,16 +496,16 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpTmpDimensionedField \
<ReturnType, Type1, Type1, Type2, GeoMesh>::New \
@ -531,13 +531,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -558,7 +558,7 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
@ -569,15 +569,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
const DimensionedField<Type2, GeoMesh>& df2 = tdf2(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type2, GeoMesh>::New \
( \
@ -595,10 +595,10 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
) \
{ \
return dimensioned<Type1>(t1) Op tdf2; \
@ -608,13 +608,13 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const dimensioned<Type2>& dt2 \
) \
{ \
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
new DimensionedField<ReturnType, GeoMesh> \
( \
@ -635,7 +635,7 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
@ -646,15 +646,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
\
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \
) \
{ \
const DimensionedField<Type1, GeoMesh>& df1 = tdf1(); \
\
tmp<DimensionedField<ReturnType, GeoMesh> > tRes \
tmp<DimensionedField<ReturnType, GeoMesh>> tRes \
( \
reuseTmpDimensionedField<ReturnType, Type1, GeoMesh>::New \
( \
@ -672,9 +672,9 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
} \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
) \
{ \

94
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldFunctionsM.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,15 +28,15 @@ License
#define UNARY_FUNCTION(ReturnType, Type1, Func, Dfunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
);
@ -45,15 +45,15 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define UNARY_OPERATOR(ReturnType, Type1, Op, opFunc, Dfunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1 \
);
@ -62,31 +62,31 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
#define BINARY_FUNCTION(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
);
@ -95,61 +95,61 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define BINARY_TYPE_FUNCTION_SF(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
);
#define BINARY_TYPE_FUNCTION_FS(ReturnType, Type1, Type2, Func) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > Func \
tmp<DimensionedField<ReturnType, GeoMesh>> Func \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf2, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf2, \
const Type2& t2 \
);
@ -164,31 +164,31 @@ tmp<DimensionedField<ReturnType, GeoMesh> > Func \
#define BINARY_OPERATOR(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
);
@ -197,61 +197,61 @@ tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
#define BINARY_TYPE_OPERATOR_SF(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const DimensionedField<Type2, GeoMesh>& df2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const dimensioned<Type1>& dt1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const Type1& t1, \
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2 \
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2 \
);
#define BINARY_TYPE_OPERATOR_FS(ReturnType, Type1, Type2, Op, OpName, OpFunc) \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const DimensionedField<Type1, GeoMesh>& df1, \
const Type2& t2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const dimensioned<Type2>& dt2 \
); \
\
TEMPLATE \
tmp<DimensionedField<ReturnType, GeoMesh> > operator Op \
tmp<DimensionedField<ReturnType, GeoMesh>> operator Op \
( \
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1, \
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1, \
const Type2& t2 \
);

4
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -29,7 +29,7 @@ template<class Type, class GeoMesh>
inline const Foam::DimensionedField<Type, GeoMesh>&
Foam::DimensionedField<Type, GeoMesh>::null()
{
return NullObjectRef<DimensionedField<Type, GeoMesh> >();
return NullObjectRef<DimensionedField<Type, GeoMesh>>();
}

4
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldIO.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -131,7 +131,7 @@ template<class Type, class GeoMesh>
Foam::Ostream& Foam::operator<<
(
Ostream& os,
const tmp<DimensionedField<Type, GeoMesh> >& tdf
const tmp<DimensionedField<Type, GeoMesh>>& tdf
)
{
tdf().writeData(os);

66
src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedFieldReuseFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -38,16 +38,16 @@ class reuseTmpDimensionedField
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1,
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const word& name,
const dimensionSet& dimensions
)
{
const DimensionedField<Type1, GeoMesh>& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -63,7 +63,7 @@ public:
);
}
static void clear(const tmp<DimensionedField<Type1, GeoMesh> >& tdf1)
static void clear(const tmp<DimensionedField<Type1, GeoMesh>>& tdf1)
{
tdf1.clear();
}
@ -75,9 +75,9 @@ class reuseTmpDimensionedField<TypeR, TypeR, GeoMesh>
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const word& name,
const dimensionSet& dimensions
)
@ -93,7 +93,7 @@ public:
}
else
{
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -110,7 +110,7 @@ public:
}
}
static void clear(const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1)
static void clear(const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1)
{
if (tdf1.isTmp())
{
@ -125,17 +125,17 @@ class reuseTmpTmpDimensionedField
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1,
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2,
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2,
const word& name,
const dimensionSet& dimensions
)
{
const DimensionedField<Type1, GeoMesh>& df1 = tdf1();
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -153,8 +153,8 @@ public:
static void clear
(
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1,
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2
)
{
tdf1.clear();
@ -168,10 +168,10 @@ class reuseTmpTmpDimensionedField<TypeR, Type1, Type12, TypeR, GeoMesh>
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf2,
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2,
const word& name,
const dimensionSet& dimensions
)
@ -188,7 +188,7 @@ public:
}
else
{
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -207,8 +207,8 @@ public:
static void clear
(
const tmp<DimensionedField<Type1, GeoMesh> >& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf2
const tmp<DimensionedField<Type1, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2
)
{
tdf1.clear();
@ -225,10 +225,10 @@ class reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, Type2, GeoMesh>
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1,
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2,
const word& name,
const dimensionSet& dimensions
)
@ -244,7 +244,7 @@ public:
}
else
{
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -263,8 +263,8 @@ public:
static void clear
(
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1,
const tmp<DimensionedField<Type2, GeoMesh> >& tdf2
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<Type2, GeoMesh>>& tdf2
)
{
if (tdf1.isTmp())
@ -281,10 +281,10 @@ class reuseTmpTmpDimensionedField<TypeR, TypeR, TypeR, TypeR, GeoMesh>
{
public:
static tmp<DimensionedField<TypeR, GeoMesh> > New
static tmp<DimensionedField<TypeR, GeoMesh>> New
(
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf2,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2,
const word& name,
const dimensionSet& dimensions
)
@ -308,7 +308,7 @@ public:
}
else
{
return tmp<DimensionedField<TypeR, GeoMesh> >
return tmp<DimensionedField<TypeR, GeoMesh>>
(
new DimensionedField<TypeR, GeoMesh>
(
@ -327,8 +327,8 @@ public:
static void clear
(
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh> >& tdf2
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf1,
const tmp<DimensionedField<TypeR, GeoMesh>>& tdf2
)
{
if (tdf1.isTmp())

6
src/OpenFOAM/fields/DimensionedFields/DimensionedField/SubDimensionedField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -103,13 +103,13 @@ public:
static inline const SubDimensionedField<Type, GeoMesh>& null();
//- Return a component field of the field
inline tmp<DimensionedField<cmptType, GeoMesh> > component
inline tmp<DimensionedField<cmptType, GeoMesh>> component
(
const direction
) const;
//- Return the field transpose (only defined for second rank tensors)
tmp<DimensionedField<Type, GeoMesh> > T() const;
tmp<DimensionedField<Type, GeoMesh>> T() const;
// Member operators

6
src/OpenFOAM/fields/DimensionedFields/DimensionedField/SubDimensionedFieldI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -74,7 +74,7 @@ template<class Type, class GeoMesh>
inline const Foam::SubDimensionedField<Type, GeoMesh>&
Foam::SubDimensionedField<Type, GeoMesh>::null()
{
return NullObjectRef<SubDimensionedField<Type, GeoMesh> >();
return NullObjectRef<SubDimensionedField<Type, GeoMesh>>();
}
@ -97,7 +97,7 @@ Foam::SubDimensionedField<Type, GeoMesh>::component
template<class Type, class GeoMesh>
inline Foam::tmp<Foam::DimensionedField<Type, GeoMesh> >
inline Foam::tmp<Foam::DimensionedField<Type, GeoMesh>>
Foam::SubDimensionedField<Type, GeoMesh>::T() const
{
return

134
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,13 +36,13 @@ namespace Foam
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > stabilise
tmp<DimensionedField<scalar, GeoMesh>> stabilise
(
const DimensionedField<scalar, GeoMesh>& dsf,
const dimensioned<scalar>& ds
)
{
tmp<DimensionedField<scalar, GeoMesh> > tRes
tmp<DimensionedField<scalar, GeoMesh>> tRes
(
new DimensionedField<scalar, GeoMesh>
(
@ -64,15 +64,15 @@ tmp<DimensionedField<scalar, GeoMesh> > stabilise
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > stabilise
tmp<DimensionedField<scalar, GeoMesh>> stabilise
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
const dimensioned<scalar>& ds
)
{
const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh> > tRes =
tmp<DimensionedField<scalar, GeoMesh>> tRes =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf,
@ -101,13 +101,13 @@ BINARY_TYPE_OPERATOR_SF(scalar, scalar, scalar, /, '|', divide)
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
tmp<DimensionedField<scalar, GeoMesh> > tPow
tmp<DimensionedField<scalar, GeoMesh>> tPow
(
new DimensionedField<scalar, GeoMesh>
(
@ -133,15 +133,15 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
tmp<DimensionedField<scalar, GeoMesh>> tPow =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf1,
@ -162,15 +162,15 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
tmp<DimensionedField<scalar, GeoMesh>> tPow =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf2,
@ -190,16 +190,16 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
tmp<DimensionedField<scalar, GeoMesh>> tPow =
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::
New
(
@ -226,13 +226,13 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const DimensionedField<scalar, GeoMesh>& dsf,
const dimensionedScalar& ds
)
{
tmp<DimensionedField<scalar, GeoMesh> > tPow
tmp<DimensionedField<scalar, GeoMesh>> tPow
(
new DimensionedField<scalar, GeoMesh>
(
@ -253,15 +253,15 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
const dimensionedScalar& ds
)
{
const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
tmp<DimensionedField<scalar, GeoMesh>> tPow =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf,
@ -277,7 +277,7 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const DimensionedField<scalar, GeoMesh>& dsf,
const scalar& s
@ -287,9 +287,9 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
const scalar& s
)
{
@ -298,13 +298,13 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const dimensionedScalar& ds,
const DimensionedField<scalar, GeoMesh>& dsf
)
{
tmp<DimensionedField<scalar, GeoMesh> > tPow
tmp<DimensionedField<scalar, GeoMesh>> tPow
(
new DimensionedField<scalar, GeoMesh>
(
@ -326,15 +326,15 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const dimensionedScalar& ds,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
)
{
const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh> > tPow =
tmp<DimensionedField<scalar, GeoMesh>> tPow =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf,
@ -350,7 +350,7 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const scalar& s,
const DimensionedField<scalar, GeoMesh>& dsf
@ -360,10 +360,10 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > pow
tmp<DimensionedField<scalar, GeoMesh>> pow
(
const scalar& s,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
)
{
return pow(dimensionedScalar(s), tdsf);
@ -373,13 +373,13 @@ tmp<DimensionedField<scalar, GeoMesh> > pow
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
tmp<DimensionedField<scalar, GeoMesh> > tAtan2
tmp<DimensionedField<scalar, GeoMesh>> tAtan2
(
new DimensionedField<scalar, GeoMesh>
(
@ -401,15 +401,15 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
const DimensionedField<scalar, GeoMesh>& dsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf1,
@ -426,15 +426,15 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const DimensionedField<scalar, GeoMesh>& dsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf2,
@ -450,16 +450,16 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf2
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf1,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf2
)
{
const DimensionedField<scalar, GeoMesh>& dsf1 = tdsf1();
const DimensionedField<scalar, GeoMesh>& dsf2 = tdsf2();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
reuseTmpTmpDimensionedField<scalar, scalar, scalar, scalar, GeoMesh>::
New
(
@ -482,13 +482,13 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const DimensionedField<scalar, GeoMesh>& dsf,
const dimensionedScalar& ds
)
{
tmp<DimensionedField<scalar, GeoMesh> > tAtan2
tmp<DimensionedField<scalar, GeoMesh>> tAtan2
(
new DimensionedField<scalar, GeoMesh>
(
@ -509,15 +509,15 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
const dimensionedScalar& ds
)
{
const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf,
@ -533,7 +533,7 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const DimensionedField<scalar, GeoMesh>& dsf,
const scalar& s
@ -543,9 +543,9 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf,
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf,
const scalar& s
)
{
@ -554,13 +554,13 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const dimensionedScalar& ds,
const DimensionedField<scalar, GeoMesh>& dsf
)
{
tmp<DimensionedField<scalar, GeoMesh> > tAtan2
tmp<DimensionedField<scalar, GeoMesh>> tAtan2
(
new DimensionedField<scalar, GeoMesh>
(
@ -582,15 +582,15 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const dimensionedScalar& ds,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
)
{
const DimensionedField<scalar, GeoMesh>& dsf = tdsf();
tmp<DimensionedField<scalar, GeoMesh> > tAtan2 =
tmp<DimensionedField<scalar, GeoMesh>> tAtan2 =
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New
(
tdsf,
@ -606,7 +606,7 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const scalar& s,
const DimensionedField<scalar, GeoMesh>& dsf
@ -616,10 +616,10 @@ tmp<DimensionedField<scalar, GeoMesh> > atan2
}
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > atan2
tmp<DimensionedField<scalar, GeoMesh>> atan2
(
const scalar& s,
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf
)
{
return atan2(dimensionedScalar(s), tdsf);
@ -670,7 +670,7 @@ UNARY_FUNCTION(scalar, scalar, y1, trans)
#define BesselFunc(func) \
\
template<class GeoMesh> \
tmp<DimensionedField<scalar, GeoMesh> > func \
tmp<DimensionedField<scalar, GeoMesh>> func \
( \
const int n, \
const DimensionedField<scalar, GeoMesh>& dsf \
@ -683,7 +683,7 @@ tmp<DimensionedField<scalar, GeoMesh> > func \
<< abort(FatalError); \
} \
\
tmp<DimensionedField<scalar, GeoMesh> > tFunc \
tmp<DimensionedField<scalar, GeoMesh>> tFunc \
( \
new DimensionedField<scalar, GeoMesh> \
( \
@ -704,10 +704,10 @@ tmp<DimensionedField<scalar, GeoMesh> > func \
} \
\
template<class GeoMesh> \
tmp<DimensionedField<scalar, GeoMesh> > func \
tmp<DimensionedField<scalar, GeoMesh>> func \
( \
const int n, \
const tmp<DimensionedField<scalar, GeoMesh> >& tdsf \
const tmp<DimensionedField<scalar, GeoMesh>>& tdsf \
) \
{ \
const DimensionedField<scalar, GeoMesh>& dsf = tdsf(); \
@ -719,7 +719,7 @@ tmp<DimensionedField<scalar, GeoMesh> > func \
<< abort(FatalError); \
} \
\
tmp<DimensionedField<scalar, GeoMesh> > tFunc \
tmp<DimensionedField<scalar, GeoMesh>> tFunc \
( \
reuseTmpDimensionedField<scalar, scalar, GeoMesh>::New \
( \

14
src/OpenFOAM/fields/DimensionedFields/DimensionedScalarField/DimensionedScalarField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -49,16 +49,16 @@ namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > stabilise
tmp<DimensionedField<scalar, GeoMesh>> stabilise
(
const DimensionedField<scalar, GeoMesh>&,
const dimensioned<scalar>&
);
template<class GeoMesh>
tmp<DimensionedField<scalar, GeoMesh> > stabilise
tmp<DimensionedField<scalar, GeoMesh>> stabilise
(
const tmp<DimensionedField<scalar, GeoMesh> >&,
const tmp<DimensionedField<scalar, GeoMesh>>&,
const dimensioned<scalar>&
);
@ -124,17 +124,17 @@ UNARY_FUNCTION(scalar, scalar, y1, trans)
#define BesselFunc(func) \
\
template<class GeoMesh> \
tmp<DimensionedField<scalar, GeoMesh> > func \
tmp<DimensionedField<scalar, GeoMesh>> func \
( \
const int n, \
const DimensionedField<scalar, GeoMesh>& \
); \
\
template<class GeoMesh> \
tmp<DimensionedField<scalar, GeoMesh> > func \
tmp<DimensionedField<scalar, GeoMesh>> func \
( \
const int n, \
const tmp<DimensionedField<scalar, GeoMesh> >& \
const tmp<DimensionedField<scalar, GeoMesh>>& \
);
BesselFunc(jn)

46
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -107,14 +107,14 @@ void checkFields
template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField()
:
PtrList<Field<Type> >()
PtrList<Field<Type>>()
{}
template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(const label size)
:
PtrList<Field<Type> >(size)
PtrList<Field<Type>>(size)
{}
@ -125,7 +125,7 @@ FieldField<Field, Type>::FieldField
const FieldField<Field, Type>& ff
)
:
PtrList<Field<Type> >(ff.size())
PtrList<Field<Type>>(ff.size())
{
forAll(*this, i)
{
@ -138,7 +138,7 @@ template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(const FieldField<Field, Type>& f)
:
refCount(),
PtrList<Field<Type> >(f)
PtrList<Field<Type>>(f)
{}
@ -146,23 +146,23 @@ template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(FieldField<Field, Type>& f, bool reUse)
:
refCount(),
PtrList<Field<Type> >(f, reUse)
PtrList<Field<Type>>(f, reUse)
{}
template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(const PtrList<Field<Type> >& tl)
FieldField<Field, Type>::FieldField(const PtrList<Field<Type>>& tl)
:
PtrList<Field<Type> >(tl)
PtrList<Field<Type>>(tl)
{}
// Construct as copy of tmp<FieldField>
#ifndef NoConstructFromTmp
template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(const tmp<FieldField<Field, Type> >& tf)
FieldField<Field, Type>::FieldField(const tmp<FieldField<Field, Type>>& tf)
:
PtrList<Field<Type> >
PtrList<Field<Type>>
(
const_cast<FieldField<Field, Type>&>(tf()),
tf.isTmp()
@ -176,20 +176,20 @@ FieldField<Field, Type>::FieldField(const tmp<FieldField<Field, Type> >& tf)
template<template<class> class Field, class Type>
FieldField<Field, Type>::FieldField(Istream& is)
:
PtrList<Field<Type> >(is)
PtrList<Field<Type>>(is)
{}
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > FieldField<Field, Type>::clone() const
tmp<FieldField<Field, Type>> FieldField<Field, Type>::clone() const
{
return tmp<FieldField<Field, Type> >(new FieldField<Field, Type>(*this));
return tmp<FieldField<Field, Type>>(new FieldField<Field, Type>(*this));
}
template<template<class> class Field, class Type>
template<class Type2>
tmp<FieldField<Field, Type> > FieldField<Field, Type>::NewCalculatedType
tmp<FieldField<Field, Type>> FieldField<Field, Type>::NewCalculatedType
(
const FieldField<Field, Type2>& ff
)
@ -204,7 +204,7 @@ tmp<FieldField<Field, Type> > FieldField<Field, Type>::NewCalculatedType
nffPtr->set(i, Field<Type>::NewCalculatedType(ff[i]).ptr());
}
return tmp<FieldField<Field, Type> >(nffPtr);
return tmp<FieldField<Field, Type>>(nffPtr);
}
@ -221,13 +221,13 @@ void FieldField<Field, Type>::negate()
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> >
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>>
FieldField<Field, Type>::component
(
const direction d
) const
{
tmp<FieldField<Field, cmptType> > Component
tmp<FieldField<Field, cmptType>> Component
(
FieldField<Field, typename FieldField<Field, Type>::cmptType>::
NewCalculatedType(*this)
@ -268,9 +268,9 @@ void FieldField<Field, Type>::replace
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > FieldField<Field, Type>::T() const
tmp<FieldField<Field, Type>> FieldField<Field, Type>::T() const
{
tmp<FieldField<Field, Type> > transpose
tmp<FieldField<Field, Type>> transpose
(
FieldField<Field, Type>::NewCalculatedType(*this)
);
@ -311,7 +311,7 @@ void FieldField<Field, Type>::operator=(const tmp<FieldField>& tf)
// This is dodgy stuff, don't try this at home.
FieldField* fieldPtr = tf.ptr();
PtrList<Field<Type> >::transfer(*fieldPtr);
PtrList<Field<Type>>::transfer(*fieldPtr);
delete fieldPtr;
}
@ -340,7 +340,7 @@ void FieldField<Field, Type>::operator op(const FieldField<Field, TYPE>& f) \
template<template<class> class Field, class Type> \
void FieldField<Field, Type>::operator op \
( \
const tmp<FieldField<Field, TYPE> >& tf \
const tmp<FieldField<Field, TYPE>>& tf \
) \
{ \
operator op(tf()); \
@ -369,13 +369,13 @@ COMPUTED_ASSIGNMENT(scalar, /=)
template<template<class> class Field, class Type>
Ostream& operator<<(Ostream& os, const FieldField<Field, Type>& f)
{
os << static_cast<const PtrList<Field<Type> >&>(f);
os << static_cast<const PtrList<Field<Type>>&>(f);
return os;
}
template<template<class> class Field, class Type>
Ostream& operator<<(Ostream& os, const tmp<FieldField<Field, Type> >& tf)
Ostream& operator<<(Ostream& os, const tmp<FieldField<Field, Type>>& tf)
{
os << tf();
tf.clear();

30
src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -62,7 +62,7 @@ template<template<class> class Field, class Type>
Ostream& operator<<
(
Ostream&,
const tmp<FieldField<Field, Type> >&
const tmp<FieldField<Field, Type>>&
);
@ -74,7 +74,7 @@ template<template<class> class Field, class Type>
class FieldField
:
public refCount,
public PtrList<Field<Type> >
public PtrList<Field<Type>>
{
public:
@ -105,23 +105,23 @@ public:
FieldField(FieldField<Field, Type>&, bool reUse);
//- Construct as copy of a PtrList<Field, Type>
FieldField(const PtrList<Field<Type> >&);
FieldField(const PtrList<Field<Type>>&);
//- Construct as copy of tmp<FieldField>
#ifndef NoConstructFromTmp
FieldField(const tmp<FieldField<Field, Type> >&);
FieldField(const tmp<FieldField<Field, Type>>&);
#endif
//- Construct from Istream
FieldField(Istream&);
//- Clone
tmp<FieldField<Field, Type> > clone() const;
tmp<FieldField<Field, Type>> clone() const;
//- Return a pointer to a new calculatedFvPatchFieldField created on
// freestore without setting patchField values
template<class Type2>
static tmp<FieldField<Field, Type> > NewCalculatedType
static tmp<FieldField<Field, Type>> NewCalculatedType
(
const FieldField<Field, Type2>& ff
);
@ -133,7 +133,7 @@ public:
void negate();
//- Return a component field of the field
tmp<FieldField<Field, cmptType> > component(const direction) const;
tmp<FieldField<Field, cmptType>> component(const direction) const;
//- Replace a component field of the field
void replace(const direction, const FieldField<Field, cmptType>&);
@ -142,26 +142,26 @@ public:
void replace(const direction, const cmptType&);
//- Return the field transpose (only defined for second rank tensors)
tmp<FieldField<Field, Type> > T() const;
tmp<FieldField<Field, Type>> T() const;
// Member operators
void operator=(const FieldField<Field, Type>&);
void operator=(const tmp<FieldField<Field, Type> >&);
void operator=(const tmp<FieldField<Field, Type>>&);
void operator=(const Type&);
void operator+=(const FieldField<Field, Type>&);
void operator+=(const tmp<FieldField<Field, Type> >&);
void operator+=(const tmp<FieldField<Field, Type>>&);
void operator-=(const FieldField<Field, Type>&);
void operator-=(const tmp<FieldField<Field, Type> >&);
void operator-=(const tmp<FieldField<Field, Type>>&);
void operator*=(const FieldField<Field, scalar>&);
void operator*=(const tmp<FieldField<Field, scalar> >&);
void operator*=(const tmp<FieldField<Field, scalar>>&);
void operator/=(const FieldField<Field, scalar>&);
void operator/=(const tmp<FieldField<Field, scalar> >&);
void operator/=(const tmp<FieldField<Field, scalar>>&);
void operator+=(const Type&);
void operator-=(const Type&);
@ -181,7 +181,7 @@ public:
friend Ostream& operator<< <Field, Type>
(
Ostream&,
const tmp<FieldField<Field, Type> >&
const tmp<FieldField<Field, Type>>&
);
};

130
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -75,14 +75,14 @@ void pow
}
template<template<class> class Field, class Type, int r>
tmp<FieldField<Field, typename powProduct<Type, r>::type> >
tmp<FieldField<Field, typename powProduct<Type, r>::type>>
pow
(
const FieldField<Field, Type>& f, typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<FieldField<Field, powProductType> > tRes
tmp<FieldField<Field, powProductType>> tRes
(
FieldField<Field, powProductType>::NewCalculatedType(f)
);
@ -91,14 +91,14 @@ pow
}
template<template<class> class Field, class Type, int r>
tmp<FieldField<Field, typename powProduct<Type, r>::type> >
tmp<FieldField<Field, typename powProduct<Type, r>::type>>
pow
(
const tmp<FieldField<Field, Type> >& tf, typename powProduct<Type, r>::type
const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<FieldField<Field, powProductType> > tRes
tmp<FieldField<Field, powProductType>> tRes
(
reuseTmpFieldField<Field, powProductType, Type>::New(tf)
);
@ -122,11 +122,11 @@ void sqr
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type> >
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const FieldField<Field, Type>& f)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<FieldField<Field, outerProductType> > tRes
tmp<FieldField<Field, outerProductType>> tRes
(
FieldField<Field, outerProductType>::NewCalculatedType(f)
);
@ -135,11 +135,11 @@ sqr(const FieldField<Field, Type>& f)
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type> >
sqr(const tmp<FieldField<Field, Type> >& tf)
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const tmp<FieldField<Field, Type>>& tf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<FieldField<Field, outerProductType> > tRes
tmp<FieldField<Field, outerProductType>> tRes
(
reuseTmpFieldField<Field, outerProductType, Type>::New(tf)
);
@ -159,9 +159,9 @@ void magSqr(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f)
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > magSqr(const FieldField<Field, Type>& f)
tmp<FieldField<Field, scalar>> magSqr(const FieldField<Field, Type>& f)
{
tmp<FieldField<Field, scalar> > tRes
tmp<FieldField<Field, scalar>> tRes
(
FieldField<Field, scalar>::NewCalculatedType(f)
);
@ -171,9 +171,9 @@ tmp<FieldField<Field, scalar> > magSqr(const FieldField<Field, Type>& f)
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > magSqr(const tmp<FieldField<Field, Type> >& tf)
tmp<FieldField<Field, scalar>> magSqr(const tmp<FieldField<Field, Type>>& tf)
{
tmp<FieldField<Field, scalar> > tRes
tmp<FieldField<Field, scalar>> tRes
(
reuseTmpFieldField<Field, scalar, Type>::New(tf)
);
@ -194,9 +194,9 @@ void mag(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f)
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > mag(const FieldField<Field, Type>& f)
tmp<FieldField<Field, scalar>> mag(const FieldField<Field, Type>& f)
{
tmp<FieldField<Field, scalar> > tRes
tmp<FieldField<Field, scalar>> tRes
(
FieldField<Field, scalar>::NewCalculatedType(f)
);
@ -206,9 +206,9 @@ tmp<FieldField<Field, scalar> > mag(const FieldField<Field, Type>& f)
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > mag(const tmp<FieldField<Field, Type> >& tf)
tmp<FieldField<Field, scalar>> mag(const tmp<FieldField<Field, Type>>& tf)
{
tmp<FieldField<Field, scalar> > tRes
tmp<FieldField<Field, scalar>> tRes
(
reuseTmpFieldField<Field, scalar, Type>::New(tf)
);
@ -233,13 +233,13 @@ void cmptMax
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMax
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
(
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
@ -248,13 +248,13 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMax
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMax
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
@ -278,13 +278,13 @@ void cmptMin
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMin
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
(
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
@ -293,13 +293,13 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMin
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMin
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
@ -323,13 +323,13 @@ void cmptAv
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
(
const FieldField<Field, Type>& f
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
FieldField<Field, cmptType>::NewCalculatedType(f)
);
@ -338,13 +338,13 @@ tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
)
{
typedef typename FieldField<Field, Type>::cmptType cmptType;
tmp<FieldField<Field, cmptType> > tRes
tmp<FieldField<Field, cmptType>> tRes
(
reuseTmpFieldField<Field, cmptType, Type>::New(tf)
);
@ -368,12 +368,12 @@ void cmptMag
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > cmptMag
tmp<FieldField<Field, Type>> cmptMag
(
const FieldField<Field, Type>& f
)
{
tmp<FieldField<Field, Type> > tRes
tmp<FieldField<Field, Type>> tRes
(
FieldField<Field, Type>::NewCalculatedType(f)
);
@ -382,12 +382,12 @@ tmp<FieldField<Field, Type> > cmptMag
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > cmptMag
tmp<FieldField<Field, Type>> cmptMag
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
)
{
tmp<FieldField<Field, Type> > tRes
tmp<FieldField<Field, Type>> tRes
(
reuseTmpFieldField<Field, Type, Type>::New(tf)
);
@ -400,7 +400,7 @@ tmp<FieldField<Field, Type> > cmptMag
#define TMP_UNARY_FUNCTION(returnType, func) \
\
template<template<class> class Field, class Type> \
returnType func(const tmp<FieldField<Field, Type> >& tf1) \
returnType func(const tmp<FieldField<Field, Type>>& tf1) \
{ \
returnType res = func(tf1()); \
tf1.clear(); \
@ -655,7 +655,7 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
@ -663,7 +663,7 @@ operator op \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
tmp<FieldField<Field1, productType>> tRes \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
@ -672,15 +672,15 @@ operator op \
} \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field, productType> > tRes \
tmp<FieldField<Field, productType>> tRes \
( \
reuseTmpFieldField<Field, productType, Type2>::New(tf2) \
); \
@ -696,15 +696,15 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
const tmp<FieldField<Field2, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
tmp<FieldField<Field1, productType>> tRes \
( \
FieldField<Field1, productType>::NewCalculatedType(f1) \
); \
@ -720,15 +720,15 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field1, Type1>>& tf1, \
const FieldField<Field2, Type2>& f2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
tmp<FieldField<Field1, productType>> tRes \
( \
reuseTmpFieldField<Field1, productType, Type1>::New(tf1) \
); \
@ -744,15 +744,15 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
const tmp<FieldField<Field1, Type1>>& tf1, \
const tmp<FieldField<Field2, Type2>>& tf2 \
) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<FieldField<Field1, productType> > tRes \
tmp<FieldField<Field1, productType>> tRes \
( \
reuseTmpTmpFieldField<Field1, productType, Type1, Type1, Type2>::New \
(tf1, tf2) \
@ -780,7 +780,7 @@ void opFunc \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
( \
const FieldField<Field, Type>& f1, \
@ -788,7 +788,7 @@ operator op \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
tmp<FieldField<Field, productType>> tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
@ -798,15 +798,15 @@ operator op \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const tmp<FieldField<Field, Type>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<FieldField<Field, productType> > tRes \
tmp<FieldField<Field, productType>> tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \
@ -832,7 +832,7 @@ void opFunc \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
@ -840,7 +840,7 @@ operator op \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
tmp<FieldField<Field, productType>> tRes \
( \
FieldField<Field, productType>::NewCalculatedType(f1) \
); \
@ -850,15 +850,15 @@ operator op \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
const tmp<FieldField<Field, Type>>& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<FieldField<Field, productType> > tRes \
tmp<FieldField<Field, productType>> tRes \
( \
reuseTmpFieldField<Field, productType, Type>::New(tf1) \
); \

80
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -55,7 +55,7 @@ void pow
);
template<template<class> class Field, class Type, int r>
tmp<FieldField<Field, typename powProduct<Type, r>::type> >
tmp<FieldField<Field, typename powProduct<Type, r>::type>>
pow
(
const FieldField<Field, Type>& f, typename powProduct<Type, r>::type
@ -63,10 +63,10 @@ pow
);
template<template<class> class Field, class Type, int r>
tmp<FieldField<Field, typename powProduct<Type, r>::type> >
tmp<FieldField<Field, typename powProduct<Type, r>::type>>
pow
(
const tmp<FieldField<Field, Type> >& tf, typename powProduct<Type, r>::type
const tmp<FieldField<Field, Type>>& tf, typename powProduct<Type, r>::type
= pTraits<typename powProduct<Type, r>::type>::zero
);
@ -79,30 +79,30 @@ void sqr
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type> >
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const FieldField<Field, Type>& f);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename outerProduct<Type, Type>::type> >
sqr(const tmp<FieldField<Field, Type> >& tf);
tmp<FieldField<Field, typename outerProduct<Type, Type>::type>>
sqr(const tmp<FieldField<Field, Type>>& tf);
template<template<class> class Field, class Type>
void magSqr(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f);
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > magSqr(const FieldField<Field, Type>& f);
tmp<FieldField<Field, scalar>> magSqr(const FieldField<Field, Type>& f);
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > magSqr(const tmp<FieldField<Field, Type> >& tf);
tmp<FieldField<Field, scalar>> magSqr(const tmp<FieldField<Field, Type>>& tf);
template<template<class> class Field, class Type>
void mag(FieldField<Field, scalar>& sf, const FieldField<Field, Type>& f);
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > mag(const FieldField<Field, Type>& f);
tmp<FieldField<Field, scalar>> mag(const FieldField<Field, Type>& f);
template<template<class> class Field, class Type>
tmp<FieldField<Field, scalar> > mag(const tmp<FieldField<Field, Type> >& tf);
tmp<FieldField<Field, scalar>> mag(const tmp<FieldField<Field, Type>>& tf);
template<template<class> class Field, class Type>
@ -113,15 +113,15 @@ void cmptMax
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMax
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
(
const FieldField<Field, Type>& f
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMax
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMax
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
);
@ -133,15 +133,15 @@ void cmptMin
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMin
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
(
const FieldField<Field, Type>& f
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptMin
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptMin
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
);
@ -153,15 +153,15 @@ void cmptAv
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
(
const FieldField<Field, Type>& f
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType> > cmptAv
tmp<FieldField<Field, typename FieldField<Field, Type>::cmptType>> cmptAv
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
);
@ -173,22 +173,22 @@ void cmptMag
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > cmptMag
tmp<FieldField<Field, Type>> cmptMag
(
const FieldField<Field, Type>& f
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > cmptMag
tmp<FieldField<Field, Type>> cmptMag
(
const tmp<FieldField<Field, Type> >& tf
const tmp<FieldField<Field, Type>>& tf
);
#define TMP_UNARY_FUNCTION(returnType, func) \
\
template<template<class> class Field, class Type> \
returnType func(const tmp<FieldField<Field, Type> >& tf1);
returnType func(const tmp<FieldField<Field, Type>>& tf1);
template<template<class> class Field, class Type>
Type max(const FieldField<Field, Type>& f);
@ -288,7 +288,7 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
@ -296,11 +296,11 @@ operator op \
); \
\
template<template<class> class Field, class Type1, class Type2> \
tmp<FieldField<Field, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
); \
\
template \
@ -310,11 +310,11 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const FieldField<Field1, Type1>& f1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
const tmp<FieldField<Field2, Type2>>& tf2 \
); \
\
template \
@ -324,10 +324,10 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field1, Type1>>& tf1, \
const FieldField<Field2, Type2>& f2 \
); \
\
@ -338,11 +338,11 @@ template \
class Type1, \
class Type2 \
> \
tmp<FieldField<Field1, typename product<Type1, Type2>::type> > \
tmp<FieldField<Field1, typename product<Type1, Type2>::type>> \
operator op \
( \
const tmp<FieldField<Field1, Type1> >& tf1, \
const tmp<FieldField<Field2, Type2> >& tf2 \
const tmp<FieldField<Field1, Type1>>& tf1, \
const tmp<FieldField<Field2, Type2>>& tf2 \
); \
\
template \
@ -356,7 +356,7 @@ void opFunc \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
( \
const FieldField<Field, Type>& f1, \
@ -365,10 +365,10 @@ operator op \
\
template \
<template<class> class Field, class Type, class Form, class Cmpt, int nCmpt> \
tmp<FieldField<Field, typename product<Type, Form>::type> > \
tmp<FieldField<Field, typename product<Type, Form>::type>> \
operator op \
( \
const tmp<FieldField<Field, Type> >& tf1, \
const tmp<FieldField<Field, Type>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
); \
\
@ -383,7 +383,7 @@ void opFunc \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
@ -392,11 +392,11 @@ operator op \
\
template \
<template<class> class Field, class Form, class Cmpt, int nCmpt, class Type> \
tmp<FieldField<Field, typename product<Form, Type>::type> > \
tmp<FieldField<Field, typename product<Form, Type>::type>> \
operator op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, \
const tmp<FieldField<Field, Type> >& tf1 \
const tmp<FieldField<Field, Type>>& tf1 \
);
PRODUCT_OPERATOR(typeOfSum, +, add)

110
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -44,12 +44,12 @@ void Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type>& f \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, ReturnType>::NewCalculatedType(f) \
); \
@ -58,12 +58,12 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type> >& tf \
const tmp<FieldField<Field, Type>>& tf \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \
@ -91,12 +91,12 @@ void OpFunc \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type>& f \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type>::NewCalculatedType(f) \
); \
@ -105,12 +105,12 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type> >& tf \
const tmp<FieldField<Field, Type>>& tf \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, Type, Type>::New(tf) \
); \
@ -139,13 +139,13 @@ void Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
@ -154,13 +154,13 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
@ -170,13 +170,13 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
@ -186,13 +186,13 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \
@ -223,13 +223,13 @@ void Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f1, \
const Type2& s \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
@ -238,13 +238,13 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
@ -271,13 +271,13 @@ void Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const Type1& s, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type2>::NewCalculatedType(f2) \
); \
@ -286,13 +286,13 @@ tmp<FieldField<Field, ReturnType> > Func \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const Type1& s, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
@ -326,13 +326,13 @@ void OpFunc \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, ReturnType>::NewCalculatedType(f1) \
); \
@ -341,13 +341,13 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
@ -357,13 +357,13 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \
@ -373,13 +373,13 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpTmpFieldField<Field, ReturnType, Type1, Type1, Type2>:: \
New(tf1, tf2) \
@ -410,13 +410,13 @@ void OpFunc \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const Type1& s, \
const FieldField<Field, Type2>& f2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type2>::NewCalculatedType(f2) \
); \
@ -425,13 +425,13 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const Type1& s, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type2>::New(tf2) \
); \
@ -458,13 +458,13 @@ void OpFunc \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const Type2& s \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
FieldField<Field, Type1>::NewCalculatedType(f1) \
); \
@ -473,13 +473,13 @@ tmp<FieldField<Field, ReturnType> > operator Op \
} \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \
) \
{ \
tmp<FieldField<Field, ReturnType> > tRes \
tmp<FieldField<Field, ReturnType>> tRes \
( \
reuseTmpFieldField<Field, ReturnType, Type1>::New(tf1) \
); \

70
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldFunctionsM.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -40,15 +40,15 @@ void Func \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const FieldField<Field, Type1>& f \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > Func \
tmp<FieldField<Field, ReturnType>> Func \
( \
const tmp<FieldField<Field, Type1> >& tf \
const tmp<FieldField<Field, Type1>>& tf \
);
@ -64,15 +64,15 @@ void OpFunc \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf \
const tmp<FieldField<Field, Type1>>& tf \
);
@ -89,31 +89,31 @@ void func \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2 \
);
@ -130,17 +130,17 @@ void func \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const Type1& s1, \
const FieldField<Field, Type1>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const Type1& s1, \
const tmp<FieldField<Field, Type1> >& tf2 \
const tmp<FieldField<Field, Type1>>& tf2 \
);
@ -155,16 +155,16 @@ void func \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const FieldField<Field, Type1>& f1, \
const Type2& s \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > func \
tmp<FieldField<Field, ReturnType>> func \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s \
);
@ -187,31 +187,31 @@ void OpFunc \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const FieldField<Field, Type2>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const FieldField<Field, Type2>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type1>>& tf1, \
const tmp<FieldField<Field, Type2>>& tf2 \
);
@ -228,17 +228,17 @@ void OpFunc \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const Type1& s1, \
const FieldField<Field, Type2>& f2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const Type1& s1, \
const tmp<FieldField<Field, Type2> >& tf2 \
const tmp<FieldField<Field, Type2>>& tf2 \
);
@ -253,16 +253,16 @@ void OpFunc \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const FieldField<Field, Type1>& f1, \
const Type2& s2 \
); \
\
TEMPLATE \
tmp<FieldField<Field, ReturnType> > operator Op \
tmp<FieldField<Field, ReturnType>> operator Op \
( \
const tmp<FieldField<Field, Type1> >& tf1, \
const tmp<FieldField<Field, Type1>>& tf1, \
const Type2& s2 \
);

66
src/OpenFOAM/fields/FieldFields/FieldField/FieldFieldReuseFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -38,18 +38,18 @@ class reuseTmpFieldField
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, Type1> >& tf1
const tmp<FieldField<Field, Type1>>& tf1
)
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
}
static void clear(const tmp<FieldField<Field, Type1> >& tf1)
static void clear(const tmp<FieldField<Field, Type1>>& tf1)
{
tf1.clear();
}
@ -61,9 +61,9 @@ class reuseTmpFieldField<Field, TypeR, TypeR>
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR> >& tf1
const tmp<FieldField<Field, TypeR>>& tf1
)
{
if (tf1.isTmp())
@ -72,14 +72,14 @@ public:
}
else
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
}
}
static void clear(const tmp<FieldField<Field, TypeR> >& tf1)
static void clear(const tmp<FieldField<Field, TypeR>>& tf1)
{
if (tf1.isTmp())
{
@ -101,13 +101,13 @@ class reuseTmpTmpFieldField
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, Type1> >& tf1,
const tmp<FieldField<Field, Type2> >& tf2
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
@ -115,8 +115,8 @@ public:
static void clear
(
const tmp<FieldField<Field, Type1> >& tf1,
const tmp<FieldField<Field, Type2> >& tf2
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
tf1.clear();
@ -130,10 +130,10 @@ class reuseTmpTmpFieldField<Field, TypeR, Type1, Type12, TypeR>
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, Type1> >& tf1,
const tmp<FieldField<Field, TypeR> >& tf2
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
if (tf2.isTmp())
@ -142,7 +142,7 @@ public:
}
else
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
@ -151,8 +151,8 @@ public:
static void clear
(
const tmp<FieldField<Field, Type1> >& tf1,
const tmp<FieldField<Field, TypeR> >& tf2
const tmp<FieldField<Field, Type1>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
tf1.clear();
@ -169,10 +169,10 @@ class reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, Type2>
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR> >& tf1,
const tmp<FieldField<Field, Type2> >& tf2
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
if (tf1.isTmp())
@ -181,7 +181,7 @@ public:
}
else
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
@ -190,8 +190,8 @@ public:
static void clear
(
const tmp<FieldField<Field, TypeR> >& tf1,
const tmp<FieldField<Field, Type2> >& tf2
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, Type2>>& tf2
)
{
if (tf1.isTmp())
@ -208,10 +208,10 @@ class reuseTmpTmpFieldField<Field, TypeR, TypeR, TypeR, TypeR>
{
public:
static tmp<FieldField<Field, TypeR> > New
static tmp<FieldField<Field, TypeR>> New
(
const tmp<FieldField<Field, TypeR> >& tf1,
const tmp<FieldField<Field, TypeR> >& tf2
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
if (tf1.isTmp())
@ -224,7 +224,7 @@ public:
}
else
{
return tmp<FieldField<Field, TypeR> >
return tmp<FieldField<Field, TypeR>>
(
FieldField<Field, TypeR>::NewCalculatedType(tf1())
);
@ -233,8 +233,8 @@ public:
static void clear
(
const tmp<FieldField<Field, TypeR> >& tf1,
const tmp<FieldField<Field, TypeR> >& tf2
const tmp<FieldField<Field, TypeR>>& tf1,
const tmp<FieldField<Field, TypeR>>& tf2
)
{
if (tf1.isTmp())

22
src/OpenFOAM/fields/FieldFields/scalarFieldField/scalarFieldField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -53,13 +53,13 @@ void stabilise
}
template<template<class> class Field>
tmp<FieldField<Field, scalar> > stabilise
tmp<FieldField<Field, scalar>> stabilise
(
const FieldField<Field, scalar>& f1,
const scalar s
)
{
tmp<FieldField<Field, scalar> > tf
tmp<FieldField<Field, scalar>> tf
(
FieldField<Field, scalar>::NewCalculatedType(f1)
);
@ -68,13 +68,13 @@ tmp<FieldField<Field, scalar> > stabilise
}
template<template<class> class Field>
tmp<FieldField<Field, scalar> > stabilise
tmp<FieldField<Field, scalar>> stabilise
(
const tmp<FieldField<Field, scalar> >& tf1,
const tmp<FieldField<Field, scalar>>& tf1,
const scalar s
)
{
tmp<FieldField<Field, scalar> > tf(tf1.ptr());
tmp<FieldField<Field, scalar>> tf(tf1.ptr());
stabilise(tf(), tf(), s);
return tf;
}
@ -152,13 +152,13 @@ void func \
} \
\
template<template<class> class Field> \
tmp<FieldField<Field, scalar> > func \
tmp<FieldField<Field, scalar>> func \
( \
const int n, \
const FieldField<Field, scalar>& sf \
) \
{ \
tmp<FieldField<Field, scalar> > tRes \
tmp<FieldField<Field, scalar>> tRes \
( \
FieldField<Field, scalar>::NewCalculatedType(sf) \
); \
@ -167,13 +167,13 @@ tmp<FieldField<Field, scalar> > func \
} \
\
template<template<class> class Field> \
tmp<FieldField<Field, scalar> > func \
tmp<FieldField<Field, scalar>> func \
( \
const int n, \
const tmp<FieldField<Field, scalar> >& tsf \
const tmp<FieldField<Field, scalar>>& tsf \
) \
{ \
tmp<FieldField<Field, scalar> > tRes \
tmp<FieldField<Field, scalar>> tRes \
( \
reuseTmpFieldField<Field, scalar, scalar>::New(tsf) \
); \

10
src/OpenFOAM/fields/FieldFields/scalarFieldField/scalarFieldField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -58,7 +58,7 @@ void stabilise
template<template<class> class Field>
tmp<FieldField<Field, scalar> > stabilise
tmp<FieldField<Field, scalar>> stabilise
(
const FieldField<Field, scalar>&,
const scalar s
@ -66,9 +66,9 @@ tmp<FieldField<Field, scalar> > stabilise
template<template<class> class Field>
tmp<FieldField<Field, scalar> > stabilise
tmp<FieldField<Field, scalar>> stabilise
(
const tmp<FieldField<Field, scalar> >&,
const tmp<FieldField<Field, scalar>>&,
const scalar s
);
@ -136,7 +136,7 @@ void func \
const FieldField<Field, scalar>& sf \
); \
tmp<scalarField> func(const int n, const FieldField<Field, scalar>&); \
tmp<scalarField> func(const int n, const tmp<FieldField<Field, scalar> >&);
tmp<scalarField> func(const int n, const tmp<FieldField<Field, scalar>>&);
BesselFunc(jn)
BesselFunc(yn)

36
src/OpenFOAM/fields/FieldFields/transformFieldField/transformFieldField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -51,13 +51,13 @@ void transform
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const FieldField<Field, tensor>& trf,
const FieldField<Field, Type>& tf
)
{
tmp<FieldField<Field, Type> > tranf
tmp<FieldField<Field, Type>> tranf
(
FieldField<Field, Type>::NewCalculatedType(tf)
);
@ -67,26 +67,26 @@ tmp<FieldField<Field, Type> > transform
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const FieldField<Field, tensor>& trf,
const tmp<FieldField<Field, Type> >& ttf
const tmp<FieldField<Field, Type>>& ttf
)
{
tmp<FieldField<Field, Type> > tranf(ttf.ptr());
tmp<FieldField<Field, Type>> tranf(ttf.ptr());
transform(tranf(), trf, tranf());
return tranf;
}
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tmp<FieldField<Field, tensor> >& ttrf,
const tmp<FieldField<Field, tensor>>& ttrf,
const FieldField<Field, Type>& tf
)
{
tmp<FieldField<Field, Type> > tranf
tmp<FieldField<Field, Type>> tranf
(
FieldField<Field, Type>::NewCalculatedType(tf)
);
@ -97,13 +97,13 @@ tmp<FieldField<Field, Type> > transform
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tmp<FieldField<Field, tensor> >& ttrf,
const tmp<FieldField<Field, Type> >& ttf
const tmp<FieldField<Field, tensor>>& ttrf,
const tmp<FieldField<Field, Type>>& ttf
)
{
tmp<FieldField<Field, Type> > tranf(ttf.ptr());
tmp<FieldField<Field, Type>> tranf(ttf.ptr());
transform(tranf(), ttrf(), tranf());
ttrf.clear();
return tranf;
@ -126,13 +126,13 @@ void transform
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tensor& t,
const FieldField<Field, Type>& tf
)
{
tmp<FieldField<Field, Type> > tranf
tmp<FieldField<Field, Type>> tranf
(
FieldField<Field, Type>::NewCalculatedType(tf)
);
@ -142,13 +142,13 @@ tmp<FieldField<Field, Type> > transform
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tensor& t,
const tmp<FieldField<Field, Type> >& ttf
const tmp<FieldField<Field, Type>>& ttf
)
{
tmp<FieldField<Field, Type> > tranf(ttf.ptr());
tmp<FieldField<Field, Type>> tranf(ttf.ptr());
transform(tranf(), t, tranf());
return tranf;
}

24
src/OpenFOAM/fields/FieldFields/transformFieldField/transformFieldField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -55,31 +55,31 @@ void transform
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const FieldField<Field, tensor>&,
const FieldField<Field, Type>&
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const FieldField<Field, tensor>&,
const tmp<FieldField<Field, Type> >&
const tmp<FieldField<Field, Type>>&
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tmp<FieldField<Field, tensor> >&,
const tmp<FieldField<Field, tensor>>&,
const FieldField<Field, Type>&
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tmp<FieldField<Field, tensor> >&,
const tmp<FieldField<Field, Type> >&
const tmp<FieldField<Field, tensor>>&,
const tmp<FieldField<Field, Type>>&
);
@ -92,17 +92,17 @@ void transform
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tensor&,
const FieldField<Field, Type>&
);
template<template<class> class Field, class Type>
tmp<FieldField<Field, Type> > transform
tmp<FieldField<Field, Type>> transform
(
const tensor&,
const tmp<FieldField<Field, Type> >&
const tmp<FieldField<Field, Type>>&
);

6
src/OpenFOAM/fields/Fields/DynamicField/DynamicField.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,10 +36,10 @@ Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::DynamicField(Istream& is)
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
Foam::tmp<Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv> >
Foam::tmp<Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>>
Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::clone() const
{
return tmp<DynamicField<T, SizeInc, SizeMult, SizeDiv> >
return tmp<DynamicField<T, SizeInc, SizeMult, SizeDiv>>
(
new DynamicField<T, SizeInc, SizeMult, SizeDiv>(*this)
);

10
src/OpenFOAM/fields/Fields/DynamicField/DynamicField.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -109,7 +109,7 @@ public:
explicit inline DynamicField(const UList<T>&);
//- Construct by transferring the parameter contents
explicit inline DynamicField(const Xfer<List<T> >&);
explicit inline DynamicField(const Xfer<List<T>>&);
//- Construct by 1 to 1 mapping from the given field
inline DynamicField
@ -139,14 +139,14 @@ public:
//- Construct by transferring the Field contents
inline DynamicField
(
const Xfer<DynamicField<T, SizeInc, SizeMult, SizeDiv> >&
const Xfer<DynamicField<T, SizeInc, SizeMult, SizeDiv>>&
);
//- Construct from Istream. Size set to size of list read.
explicit DynamicField(Istream&);
//- Clone
tmp<DynamicField<T, SizeInc, SizeMult, SizeDiv> > clone() const;
tmp<DynamicField<T, SizeInc, SizeMult, SizeDiv>> clone() const;
// Member Functions
@ -200,7 +200,7 @@ public:
inline DynamicField<T, SizeInc, SizeMult, SizeDiv>& shrink();
//- Transfer contents to the Xfer container as a plain List
inline Xfer<List<T> > xfer();
inline Xfer<List<T>> xfer();
// Member Operators

6
src/OpenFOAM/fields/Fields/DynamicField/DynamicFieldI.H
View File

@ -61,7 +61,7 @@ inline Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::DynamicField
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::DynamicField
(
const Xfer<List<T> >& lst
const Xfer<List<T>>& lst
)
:
Field<T>(lst),
@ -121,7 +121,7 @@ inline Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::DynamicField
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::DynamicField
(
const Xfer<DynamicField<T, SizeInc, SizeMult, SizeDiv> >& lst
const Xfer<DynamicField<T, SizeInc, SizeMult, SizeDiv>>& lst
)
:
Field<T>(lst),
@ -308,7 +308,7 @@ Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::shrink()
template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
inline Foam::Xfer<Foam::List<T> >
inline Foam::Xfer<Foam::List<T>>
Foam::DynamicField<T, SizeInc, SizeMult, SizeDiv>::xfer()
{
return xferMoveTo<List<T>>(*this);

46
src/OpenFOAM/fields/Fields/Field/Field.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -73,7 +73,7 @@ Foam::Field<Type>::Field
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
:
@ -100,7 +100,7 @@ Foam::Field<Type>::Field
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
@ -155,7 +155,7 @@ Foam::Field<Type>::Field
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper
)
:
@ -168,7 +168,7 @@ Foam::Field<Type>::Field
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper,
const Type& defaultValue
)
@ -182,7 +182,7 @@ Foam::Field<Type>::Field
template<class Type>
Foam::Field<Type>::Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper,
const UList<Type>& defaultValues
)
@ -209,14 +209,14 @@ Foam::Field<Type>::Field(Field<Type>& f, bool reUse)
template<class Type>
Foam::Field<Type>::Field(const Xfer<List<Type> >& f)
Foam::Field<Type>::Field(const Xfer<List<Type>>& f)
:
List<Type>(f)
{}
template<class Type>
Foam::Field<Type>::Field(const Xfer<Field<Type> >& f)
Foam::Field<Type>::Field(const Xfer<Field<Type>>& f)
:
List<Type>(f)
{}
@ -232,7 +232,7 @@ Foam::Field<Type>::Field(const UList<Type>& list)
// Construct as copy of tmp<Field>
#ifndef NoConstructFromTmp
template<class Type>
Foam::Field<Type>::Field(const tmp<Field<Type> >& tf)
Foam::Field<Type>::Field(const tmp<Field<Type>>& tf)
:
List<Type>(const_cast<Field<Type>&>(tf()), tf.isTmp())
{
@ -324,9 +324,9 @@ Foam::Field<Type>::Field
template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::Field<Type>::clone() const
Foam::tmp<Foam::Field<Type>> Foam::Field<Type>::clone() const
{
return tmp<Field<Type> >(new Field<Type>(*this));
return tmp<Field<Type>>(new Field<Type>(*this));
}
@ -364,7 +364,7 @@ void Foam::Field<Type>::map
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
{
@ -413,7 +413,7 @@ void Foam::Field<Type>::map
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& mapWeights
)
@ -449,7 +449,7 @@ void Foam::Field<Type>::map
template<class Type>
void Foam::Field<Type>::map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& mapper
)
{
@ -508,7 +508,7 @@ void Foam::Field<Type>::rmap
template<class Type>
void Foam::Field<Type>::rmap
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
)
{
@ -539,7 +539,7 @@ void Foam::Field<Type>::rmap
template<class Type>
void Foam::Field<Type>::rmap
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing,
const UList<scalar>& mapWeights
)
@ -557,13 +557,13 @@ void Foam::Field<Type>::negate()
template<class Type>
Foam::tmp<Foam::Field<typename Foam::Field<Type>::cmptType> >
Foam::tmp<Foam::Field<typename Foam::Field<Type>::cmptType>>
Foam::Field<Type>::component
(
const direction d
) const
{
tmp<Field<cmptType> > Component(new Field<cmptType>(this->size()));
tmp<Field<cmptType>> Component(new Field<cmptType>(this->size()));
::Foam::component(Component(), *this, d);
return Component;
}
@ -585,7 +585,7 @@ template<class Type>
void Foam::Field<Type>::replace
(
const direction d,
const tmp<Field<cmptType> >& tsf
const tmp<Field<cmptType>>& tsf
)
{
replace(d, tsf());
@ -606,9 +606,9 @@ void Foam::Field<Type>::replace
template<class Type>
Foam::tmp<Foam::Field<Type> > Foam::Field<Type>::T() const
Foam::tmp<Foam::Field<Type>> Foam::Field<Type>::T() const
{
tmp<Field<Type> > transpose(new Field<Type>(this->size()));
tmp<Field<Type>> transpose(new Field<Type>(this->size()));
::Foam::T(transpose(), *this);
return transpose;
}
@ -721,7 +721,7 @@ void Foam::Field<Type>::operator op(const UList<TYPE>& f) \
} \
\
template<class Type> \
void Foam::Field<Type>::operator op(const tmp<Field<TYPE> >& tf) \
void Foam::Field<Type>::operator op(const tmp<Field<TYPE>>& tf) \
{ \
operator op(tf()); \
tf.clear(); \
@ -752,7 +752,7 @@ Foam::Ostream& Foam::operator<<(Ostream& os, const Field<Type>& f)
template<class Type>
Foam::Ostream& Foam::operator<<(Ostream& os, const tmp<Field<Type> >& tf)
Foam::Ostream& Foam::operator<<(Ostream& os, const tmp<Field<Type>>& tf)
{
os << tf();
tf.clear();

56
src/OpenFOAM/fields/Fields/Field/Field.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -65,7 +65,7 @@ template<class Type>
Ostream& operator<<(Ostream&, const Field<Type>&);
template<class Type>
Ostream& operator<<(Ostream&, const tmp<Field<Type> >&);
Ostream& operator<<(Ostream&, const tmp<Field<Type>>&);
class FieldMapper;
class dictionary;
@ -100,7 +100,7 @@ public:
//- Return a null field
inline static const Field<Type>& null()
{
return NullObjectRef<Field<Type> >();
return NullObjectRef<Field<Type>>();
}
@ -121,7 +121,7 @@ public:
explicit Field(const UList<Type>&);
//- Construct by transferring the List contents
explicit Field(const Xfer<List<Type> >&);
explicit Field(const Xfer<List<Type>>&);
//- Construct by 1 to 1 mapping from the given field
Field
@ -133,7 +133,7 @@ public:
//- Construct by 1 to 1 mapping from the given tmp field
Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
);
@ -148,7 +148,7 @@ public:
//- Construct by interpolative mapping from the given tmp field
Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& weights
);
@ -179,7 +179,7 @@ public:
//- Construct by mapping from the given tmp field
Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& map
);
@ -187,7 +187,7 @@ public:
// value for unmapped items
Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& map,
const Type& defaultValue
);
@ -196,7 +196,7 @@ public:
// for unmapped items
Field
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& map,
const UList<Type>& defaultValues
);
@ -208,11 +208,11 @@ public:
Field(Field<Type>&, bool reUse);
//- Construct by transferring the Field contents
Field(const Xfer<Field<Type> >&);
Field(const Xfer<Field<Type>>&);
//- Construct as copy of tmp<Field>
#ifndef NoConstructFromTmp
Field(const tmp<Field<Type> >&);
Field(const tmp<Field<Type>>&);
#endif
//- Construct from Istream
@ -222,14 +222,14 @@ public:
Field(const word& keyword, const dictionary&, const label size);
//- Clone
tmp<Field<Type> > clone() const;
tmp<Field<Type>> clone() const;
//- Return a pointer to a new calculatedFvPatchFieldField created on
// freestore without setting patchField values
template<class Type2>
static tmp<Field<Type> > NewCalculatedType(const Field<Type2>& f)
static tmp<Field<Type>> NewCalculatedType(const Field<Type2>& f)
{
return tmp<Field<Type> >(new Field<Type>(f.size()));
return tmp<Field<Type>>(new Field<Type>(f.size()));
}
@ -245,7 +245,7 @@ public:
//- 1 to 1 map from the given tmp field
void map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
);
@ -260,7 +260,7 @@ public:
//- Interpolative map from the given tmp field
void map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelListList& mapAddressing,
const scalarListList& weights
);
@ -275,7 +275,7 @@ public:
//- Map from the given tmp field
void map
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const FieldMapper& map
);
@ -295,7 +295,7 @@ public:
//- 1 to 1 reverse-map from the given tmp field
void rmap
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing
);
@ -310,7 +310,7 @@ public:
//- Interpolative reverse map from the given tmp field
void rmap
(
const tmp<Field<Type> >& tmapF,
const tmp<Field<Type>>& tmapF,
const labelUList& mapAddressing,
const UList<scalar>& weights
);
@ -319,19 +319,19 @@ public:
void negate();
//- Return a component field of the field
tmp<Field<cmptType> > component(const direction) const;
tmp<Field<cmptType>> component(const direction) const;
//- Replace a component field of the field
void replace(const direction, const UList<cmptType>&);
//- Replace a component field of the field
void replace(const direction, const tmp<Field<cmptType> >&);
void replace(const direction, const tmp<Field<cmptType>>&);
//- Replace a component field of the field
void replace(const direction, const cmptType&);
//- Return the field transpose (only defined for second rank tensors)
tmp<Field<Type> > T() const;
tmp<Field<Type>> T() const;
//- Write the field as a dictionary entry
void writeEntry(const word& keyword, Ostream& os) const;
@ -342,23 +342,23 @@ public:
void operator=(const Field<Type>&);
void operator=(const UList<Type>&);
void operator=(const SubField<Type>&);
void operator=(const tmp<Field<Type> >&);
void operator=(const tmp<Field<Type>>&);
void operator=(const Type&);
template<class Form, class Cmpt, int nCmpt>
void operator=(const VectorSpace<Form,Cmpt,nCmpt>&);
void operator+=(const UList<Type>&);
void operator+=(const tmp<Field<Type> >&);
void operator+=(const tmp<Field<Type>>&);
void operator-=(const UList<Type>&);
void operator-=(const tmp<Field<Type> >&);
void operator-=(const tmp<Field<Type>>&);
void operator*=(const UList<scalar>&);
void operator*=(const tmp<Field<scalar> >&);
void operator*=(const tmp<Field<scalar>>&);
void operator/=(const UList<scalar>&);
void operator/=(const tmp<Field<scalar> >&);
void operator/=(const tmp<Field<scalar>>&);
void operator+=(const Type&);
void operator-=(const Type&);
@ -373,7 +373,7 @@ public:
(Ostream&, const Field<Type>&);
friend Ostream& operator<< <Type>
(Ostream&, const tmp<Field<Type> >&);
(Ostream&, const tmp<Field<Type>>&);
};

114
src/OpenFOAM/fields/Fields/Field/FieldFunctions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -75,7 +75,7 @@ void pow
}
template<class Type, int r>
tmp<Field<typename powProduct<Type, r>::type> >
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const UList<Type>& f,
@ -83,7 +83,7 @@ pow
)
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<Field<powProductType> > tRes
tmp<Field<powProductType>> tRes
(
new Field<powProductType>(f.size())
);
@ -92,15 +92,15 @@ pow
}
template<class Type, int r>
tmp<Field<typename powProduct<Type, r>::type> >
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const tmp<Field<Type> >& tf,
const tmp<Field<Type>>& tf,
typename powProduct<Type, r>::type
)
{
typedef typename powProduct<Type, r>::type powProductType;
tmp<Field<powProductType> > tRes = reuseTmp<powProductType, Type>::New(tf);
tmp<Field<powProductType>> tRes = reuseTmp<powProductType, Type>::New(tf);
pow<Type, r>(tRes(), tf());
reuseTmp<powProductType, Type>::clear(tf);
return tRes;
@ -119,11 +119,11 @@ void sqr
}
template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type> >
tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const UList<Type>& f)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<Field<outerProductType> > tRes
tmp<Field<outerProductType>> tRes
(
new Field<outerProductType>(f.size())
);
@ -132,11 +132,11 @@ sqr(const UList<Type>& f)
}
template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type> >
sqr(const tmp<Field<Type> >& tf)
tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const tmp<Field<Type>>& tf)
{
typedef typename outerProduct<Type, Type>::type outerProductType;
tmp<Field<outerProductType> > tRes =
tmp<Field<outerProductType>> tRes =
reuseTmp<outerProductType, Type>::New(tf);
sqr(tRes(), tf());
reuseTmp<outerProductType, Type>::clear(tf);
@ -151,17 +151,17 @@ void magSqr(Field<scalar>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<scalar> > magSqr(const UList<Type>& f)
tmp<Field<scalar>> magSqr(const UList<Type>& f)
{
tmp<Field<scalar> > tRes(new Field<scalar>(f.size()));
tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
magSqr(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<scalar> > magSqr(const tmp<Field<Type> >& tf)
tmp<Field<scalar>> magSqr(const tmp<Field<Type>>& tf)
{
tmp<Field<scalar> > tRes = reuseTmp<scalar, Type>::New(tf);
tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
magSqr(tRes(), tf());
reuseTmp<scalar, Type>::clear(tf);
return tRes;
@ -175,17 +175,17 @@ void mag(Field<scalar>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<scalar> > mag(const UList<Type>& f)
tmp<Field<scalar>> mag(const UList<Type>& f)
{
tmp<Field<scalar> > tRes(new Field<scalar>(f.size()));
tmp<Field<scalar>> tRes(new Field<scalar>(f.size()));
mag(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<scalar> > mag(const tmp<Field<Type> >& tf)
tmp<Field<scalar>> mag(const tmp<Field<Type>>& tf)
{
tmp<Field<scalar> > tRes = reuseTmp<scalar, Type>::New(tf);
tmp<Field<scalar>> tRes = reuseTmp<scalar, Type>::New(tf);
mag(tRes(), tf());
reuseTmp<scalar, Type>::clear(tf);
return tRes;
@ -200,19 +200,19 @@ void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMax(const UList<Type>& f)
tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
cmptMax(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMax(const tmp<Field<Type> >& tf)
tmp<Field<typename Field<Type>::cmptType>> cmptMax(const tmp<Field<Type>>& tf)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
cmptMax(tRes(), tf());
reuseTmp<cmptType, Type>::clear(tf);
return tRes;
@ -227,19 +227,19 @@ void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMin(const UList<Type>& f)
tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
cmptMin(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMin(const tmp<Field<Type> >& tf)
tmp<Field<typename Field<Type>::cmptType>> cmptMin(const tmp<Field<Type>>& tf)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
cmptMin(tRes(), tf());
reuseTmp<cmptType, Type>::clear(tf);
return tRes;
@ -254,19 +254,19 @@ void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptAv(const UList<Type>& f)
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes(new Field<cmptType>(f.size()));
tmp<Field<cmptType>> tRes(new Field<cmptType>(f.size()));
cmptAv(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptAv(const tmp<Field<Type> >& tf)
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf)
{
typedef typename Field<Type>::cmptType cmptType;
tmp<Field<cmptType> > tRes = reuseTmp<cmptType, Type>::New(tf);
tmp<Field<cmptType>> tRes = reuseTmp<cmptType, Type>::New(tf);
cmptAv(tRes(), tf());
reuseTmp<cmptType, Type>::clear(tf);
return tRes;
@ -280,17 +280,17 @@ void cmptMag(Field<Type>& res, const UList<Type>& f)
}
template<class Type>
tmp<Field<Type> > cmptMag(const UList<Type>& f)
tmp<Field<Type>> cmptMag(const UList<Type>& f)
{
tmp<Field<Type> > tRes(new Field<Type>(f.size()));
tmp<Field<Type>> tRes(new Field<Type>(f.size()));
cmptMag(tRes(), f);
return tRes;
}
template<class Type>
tmp<Field<Type> > cmptMag(const tmp<Field<Type> >& tf)
tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf)
{
tmp<Field<Type> > tRes = reuseTmp<Type, Type>::New(tf);
tmp<Field<Type>> tRes = reuseTmp<Type, Type>::New(tf);
cmptMag(tRes(), tf());
reuseTmp<Type, Type>::clear(tf);
return tRes;
@ -300,7 +300,7 @@ tmp<Field<Type> > cmptMag(const tmp<Field<Type> >& tf)
#define TMP_UNARY_FUNCTION(ReturnType, Func) \
\
template<class Type> \
ReturnType Func(const tmp<Field<Type> >& tf1) \
ReturnType Func(const tmp<Field<Type>>& tf1) \
{ \
ReturnType res = Func(tf1()); \
tf1.clear(); \
@ -648,43 +648,43 @@ void OpFunc \
} \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const UList<Type2>& f2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<Field<productType> > tRes(new Field<productType>(f1.size())); \
tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
OpFunc(tRes(), f1, f2); \
return tRes; \
} \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2> >& tf2) \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<Field<productType> > tRes = reuseTmp<productType, Type2>::New(tf2); \
tmp<Field<productType>> tRes = reuseTmp<productType, Type2>::New(tf2); \
OpFunc(tRes(), f1, tf2()); \
reuseTmp<productType, Type2>::clear(tf2); \
return tRes; \
} \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const tmp<Field<Type1> >& tf1, const UList<Type2>& f2) \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<Field<productType> > tRes = reuseTmp<productType, Type1>::New(tf1); \
tmp<Field<productType>> tRes = reuseTmp<productType, Type1>::New(tf1); \
OpFunc(tRes(), tf1(), f2); \
reuseTmp<productType, Type1>::clear(tf1); \
return tRes; \
} \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const tmp<Field<Type1> >& tf1, const tmp<Field<Type2> >& tf2) \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2) \
{ \
typedef typename product<Type1, Type2>::type productType; \
tmp<Field<productType> > tRes = \
tmp<Field<productType>> tRes = \
reuseTmpTmp<productType, Type1, Type1, Type2>::New(tf1, tf2); \
OpFunc(tRes(), tf1(), tf2()); \
reuseTmpTmp<productType, Type1, Type1, Type2>::clear(tf1, tf2); \
@ -705,25 +705,25 @@ void OpFunc \
} \
\
template<class Type, class Form, class Cmpt, int nCmpt> \
tmp<Field<typename product<Type, Form>::type> > \
tmp<Field<typename product<Type, Form>::type>> \
operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<Field<productType> > tRes(new Field<productType>(f1.size())); \
tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
OpFunc(tRes(), f1, static_cast<const Form&>(vs)); \
return tRes; \
} \
\
template<class Type, class Form, class Cmpt, int nCmpt> \
tmp<Field<typename product<Type, Form>::type> > \
tmp<Field<typename product<Type, Form>::type>> \
operator Op \
( \
const tmp<Field<Type> >& tf1, \
const tmp<Field<Type>>& tf1, \
const VectorSpace<Form,Cmpt,nCmpt>& vs \
) \
{ \
typedef typename product<Type, Form>::type productType; \
tmp<Field<productType> > tRes = reuseTmp<productType, Type>::New(tf1); \
tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1); \
OpFunc(tRes(), tf1(), static_cast<const Form&>(vs)); \
reuseTmp<productType, Type>::clear(tf1); \
return tRes; \
@ -743,24 +743,24 @@ void OpFunc \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type> \
tmp<Field<typename product<Form, Type>::type> > \
tmp<Field<typename product<Form, Type>::type>> \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<Field<productType> > tRes(new Field<productType>(f1.size())); \
tmp<Field<productType>> tRes(new Field<productType>(f1.size())); \
OpFunc(tRes(), static_cast<const Form&>(vs), f1); \
return tRes; \
} \
\
template<class Form, class Cmpt, int nCmpt, class Type> \
tmp<Field<typename product<Form, Type>::type> > \
tmp<Field<typename product<Form, Type>::type>> \
operator Op \
( \
const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type> >& tf1 \
const VectorSpace<Form,Cmpt,nCmpt>& vs, const tmp<Field<Type>>& tf1 \
) \
{ \
typedef typename product<Form, Type>::type productType; \
tmp<Field<productType> > tRes = reuseTmp<productType, Type>::New(tf1); \
tmp<Field<productType>> tRes = reuseTmp<productType, Type>::New(tf1); \
OpFunc(tRes(), static_cast<const Form&>(vs), tf1()); \
reuseTmp<productType, Type>::clear(tf1); \
return tRes; \

70
src/OpenFOAM/fields/Fields/Field/FieldFunctions.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2014 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -56,7 +56,7 @@ void pow
template<class Type, int r>
tmp<Field<typename powProduct<Type, r>::type> >
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const UList<Type>& f,
@ -65,10 +65,10 @@ pow
);
template<class Type, int r>
tmp<Field<typename powProduct<Type, r>::type> >
tmp<Field<typename powProduct<Type, r>::type>>
pow
(
const tmp<Field<Type> >& tf,
const tmp<Field<Type>>& tf,
typename powProduct<Type, r>::type
= pTraits<typename powProduct<Type, r>::type>::zero
);
@ -82,79 +82,79 @@ void sqr
);
template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type> >
tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const UList<Type>& f);
template<class Type>
tmp<Field<typename outerProduct<Type, Type>::type> >
sqr(const tmp<Field<Type> >& tf);
tmp<Field<typename outerProduct<Type, Type>::type>>
sqr(const tmp<Field<Type>>& tf);
template<class Type>
void magSqr(Field<scalar>& res, const UList<Type>& f);
template<class Type>
tmp<Field<scalar> > magSqr(const UList<Type>& f);
tmp<Field<scalar>> magSqr(const UList<Type>& f);
template<class Type>
tmp<Field<scalar> > magSqr(const tmp<Field<Type> >& tf);
tmp<Field<scalar>> magSqr(const tmp<Field<Type>>& tf);
template<class Type>
void mag(Field<scalar>& res, const UList<Type>& f);
template<class Type>
tmp<Field<scalar> > mag(const UList<Type>& f);
tmp<Field<scalar>> mag(const UList<Type>& f);
template<class Type>
tmp<Field<scalar> > mag(const tmp<Field<Type> >& tf);
tmp<Field<scalar>> mag(const tmp<Field<Type>>& tf);
template<class Type>
void cmptMax(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMax(const UList<Type>& f);
tmp<Field<typename Field<Type>::cmptType>> cmptMax(const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> >
cmptMax(const tmp<Field<Type> >& tf);
tmp<Field<typename Field<Type>::cmptType>>
cmptMax(const tmp<Field<Type>>& tf);
template<class Type>
void cmptMin(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptMin(const UList<Type>& f);
tmp<Field<typename Field<Type>::cmptType>> cmptMin(const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> >
cmptMin(const tmp<Field<Type> >& tf);
tmp<Field<typename Field<Type>::cmptType>>
cmptMin(const tmp<Field<Type>>& tf);
template<class Type>
void cmptAv(Field<typename Field<Type>::cmptType>& res, const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptAv(const UList<Type>& f);
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const UList<Type>& f);
template<class Type>
tmp<Field<typename Field<Type>::cmptType> > cmptAv(const tmp<Field<Type> >& tf);
tmp<Field<typename Field<Type>::cmptType>> cmptAv(const tmp<Field<Type>>& tf);
template<class Type>
void cmptMag(Field<Type>& res, const UList<Type>& f);
template<class Type>
tmp<Field<Type> > cmptMag(const UList<Type>& f);
tmp<Field<Type>> cmptMag(const UList<Type>& f);
template<class Type>
tmp<Field<Type> > cmptMag(const tmp<Field<Type> >& tf);
tmp<Field<Type>> cmptMag(const tmp<Field<Type>>& tf);
#define TMP_UNARY_FUNCTION(ReturnType, Func) \
\
template<class Type> \
ReturnType Func(const tmp<Field<Type> >& tf1);
ReturnType Func(const tmp<Field<Type>>& tf1);
template<class Type>
Type max(const UList<Type>& f);
@ -292,20 +292,20 @@ void OpFunc \
); \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const UList<Type2>& f2); \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2> >& tf2); \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const UList<Type1>& f1, const tmp<Field<Type2>>& tf2); \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const tmp<Field<Type1> >& tf1, const UList<Type2>& f2); \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const UList<Type2>& f2); \
\
template<class Type1, class Type2> \
tmp<Field<typename product<Type1, Type2>::type> > \
operator Op(const tmp<Field<Type1> >& tf1, const tmp<Field<Type2> >& tf2); \
tmp<Field<typename product<Type1, Type2>::type>> \
operator Op(const tmp<Field<Type1>>& tf1, const tmp<Field<Type2>>& tf2); \
\
template<class Type, class Form, class Cmpt, int nCmpt> \
void OpFunc \
@ -316,12 +316,12 @@ void OpFunc \
); \
\
template<class Type, class Form, class Cmpt, int nCmpt> \
tmp<Field<typename product<Type, Form>::type> > \
tmp<Field<typename product<Type, Form>::type>> \
operator Op(const UList<Type>& f1, const VectorSpace<Form,Cmpt,nCmpt>& vs); \
\
template<class Type, class Form, class Cmpt, int nCmpt> \
tmp<Field<typename product<Type, Form>::type> > \
operator Op(const tmp<Field<Type> >&tf1,const VectorSpace<Form,Cmpt,nCmpt>&vs);\
tmp<Field<typename product<Type, Form>::type>> \
operator Op(const tmp<Field<Type>>&tf1,const VectorSpace<Form,Cmpt,nCmpt>&vs);\
\
template<class Form, class Cmpt, int nCmpt, class Type> \
void OpFunc \
@ -332,12 +332,12 @@ void OpFunc \
); \
\
template<class Form, class Cmpt, int nCmpt, class Type> \
tmp<Field<typename product<Form, Type>::type> > \
tmp<Field<typename product<Form, Type>::type>> \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>& vs, const UList<Type>& f1); \
\
template<class Form, class Cmpt, int nCmpt, class Type> \
tmp<Field<typename product<Form, Type>::type> > \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>&vs,const tmp<Field<Type> >&tf1);
tmp<Field<typename product<Form, Type>::type>> \
operator Op(const VectorSpace<Form,Cmpt,nCmpt>&vs,const tmp<Field<Type>>&tf1);
PRODUCT_OPERATOR(typeOfSum, +, add)
PRODUCT_OPERATOR(typeOfSum, -, subtract)

Some files were not shown because too many files have changed in this diff Show More