diff --git a/src/OpenFOAM/memory/tmpNrc/tmpNrc.H b/src/OpenFOAM/memory/tmpNrc/tmpNrc.H
new file mode 100644
index 0000000000000000000000000000000000000000..8a8ae021e0da3a143c63e69ada332819906bf89c
--- /dev/null
+++ b/src/OpenFOAM/memory/tmpNrc/tmpNrc.H
@@ -0,0 +1,171 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
+
+Class
+ Foam::tmpNrc
+
+Description
+ A class for managing temporary objects without reference counting.
+
+SourceFiles
+ tmpNrcI.H
+
+SeeAlso
+ Foam::autoPtr
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tmpNrc_H
+#define tmpNrc_H
+
+#include "word.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+ Class tmpNrc Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class T>
+class tmpNrc
+{
+ // Private data
+
+ //- Object types
+ enum type
+ {
+ TMP,
+ CONST_REF
+ };
+
+ //- Type of object
+ mutable type type_;
+
+ //- Pointer to object
+ mutable T* ptr_;
+
+
+public:
+
+ // Null reference counter class
+ class refCount
+ {
+ public:
+
+ refCount()
+ {}
+ };
+
+
+ // Constructors
+
+ //- Store object pointer
+ inline explicit tmpNrc(T* = 0);
+
+ //- Store object const reference
+ inline tmpNrc(const T&);
+
+ //- Construct copy and increment reference count
+ inline tmpNrc(const tmpNrc<T>&);
+
+ //- Construct copy transferring content of temporary if required
+ inline tmpNrc(const tmpNrc<T>&, bool allowTransfer);
+
+
+ //- Destructor: deletes temporary object when the reference count is 0
+ inline ~tmpNrc();
+
+
+ // Member Functions
+
+ // Access
+
+ //- Return true if this is really a temporary object
+ inline bool isTmp() const;
+
+ //- Return true if this temporary object empty,
+ // ie, a temporary without allocation
+ inline bool empty() const;
+
+ //- Is this temporary object valid,
+ // ie, it is a reference or a temporary that has been allocated
+ inline bool valid() const;
+
+ //- Return the type name of the tmpNrc
+ // constructed from the type name of T
+ inline word typeName() const;
+
+
+ // Edit
+
+ //- Return non-const reference or generate a fatal error
+ // if the object is const.
+ inline T& ref();
+
+ //- Return tmpNrc pointer for reuse.
+ // Returns a clone if the object is not a temporary
+ inline T* ptr() const;
+
+ //- If object pointer points to valid object:
+ // delete object and set pointer to NULL
+ inline void clear() const;
+
+
+ // Member operators
+
+ //- Const dereference operator
+ inline const T& operator()() const;
+
+ //- Const cast to the underlying type reference
+ inline operator const T&() const;
+
+ //- Return object pointer
+ inline T* operator->();
+
+ //- Return const object pointer
+ inline const T* operator->() const;
+
+ //- Assignment to pointer changing this tmpNrc to a temporary T
+ inline void operator=(T*);
+
+ //- Assignment transfering the temporary T to this tmpNrc
+ inline void operator=(const tmpNrc<T>&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tmpNrcI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/memory/tmpNrc/tmpNrcI.H b/src/OpenFOAM/memory/tmpNrc/tmpNrcI.H
new file mode 100644
index 0000000000000000000000000000000000000000..b56a4c4407ae4682dfe218401b389e85163fef48
--- /dev/null
+++ b/src/OpenFOAM/memory/tmpNrc/tmpNrcI.H
@@ -0,0 +1,320 @@
+/*--------------------------------------------------------------------r-------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software: you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "error.H"
+#include <typeinfo>
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+template<class T>
+inline Foam::tmpNrc<T>::tmpNrc(T* tPtr)
+:
+ type_(TMP),
+ ptr_(tPtr)
+{}
+
+
+template<class T>
+inline Foam::tmpNrc<T>::tmpNrc(const T& tRef)
+:
+ type_(CONST_REF),
+ ptr_(const_cast<T*>(&tRef))
+{}
+
+
+template<class T>
+inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t)
+:
+ type_(t.type_),
+ ptr_(t.ptr_)
+{
+ if (isTmp())
+ {
+ if (ptr_)
+ {
+ t.type_ = CONST_REF;
+ }
+ else
+ {
+ FatalErrorInFunction
+ << "Attempted copy of a deallocated " << typeName()
+ << abort(FatalError);
+ }
+ }
+}
+
+
+template<class T>
+inline Foam::tmpNrc<T>::tmpNrc(const tmpNrc<T>& t, bool allowTransfer)
+:
+ type_(t.type_),
+ ptr_(t.ptr_)
+{
+ if (isTmp())
+ {
+ if (ptr_)
+ {
+ if (allowTransfer)
+ {
+ t.ptr_ = 0;
+ }
+ else
+ {
+ t.type_ = CONST_REF;
+ }
+ }
+ else
+ {
+ FatalErrorInFunction
+ << "Attempted copy of a deallocated " << typeName()
+ << abort(FatalError);
+ }
+ }
+}
+
+
+template<class T>
+inline Foam::tmpNrc<T>::~tmpNrc()
+{
+ clear();
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
+
+template<class T>
+inline bool Foam::tmpNrc<T>::isTmp() const
+{
+ return type_ == TMP;
+}
+
+
+template<class T>
+inline bool Foam::tmpNrc<T>::empty() const
+{
+ return (isTmp() && !ptr_);
+}
+
+
+template<class T>
+inline bool Foam::tmpNrc<T>::valid() const
+{
+ return (!isTmp() || (isTmp() && ptr_));
+}
+
+
+template<class T>
+inline Foam::word Foam::tmpNrc<T>::typeName() const
+{
+ return "tmpNrc<" + word(typeid(T).name()) + '>';
+}
+
+
+template<class T>
+inline T& Foam::tmpNrc<T>::ref()
+{
+ if (isTmp())
+ {
+ if (!ptr_)
+ {
+ FatalErrorInFunction
+ << typeName() << " deallocated"
+ << abort(FatalError);
+ }
+ }
+ else
+ {
+ FatalErrorInFunction
+ << "Attempt to acquire non-const reference to const object"
+ << " from a " << typeName()
+ << abort(FatalError);
+ }
+
+ return *ptr_;
+}
+
+
+template<class T>
+inline T* Foam::tmpNrc<T>::ptr() const
+{
+ if (isTmp())
+ {
+ if (!ptr_)
+ {
+ FatalErrorInFunction
+ << typeName() << " deallocated"
+ << abort(FatalError);
+ }
+
+ T* ptr = ptr_;
+ ptr_ = 0;
+
+ return ptr;
+ }
+ else
+ {
+ return new T(*ptr_);
+ }
+}
+
+
+template<class T>
+inline void Foam::tmpNrc<T>::clear() const
+{
+ if (isTmp() && ptr_)
+ {
+ delete ptr_;
+ ptr_ = 0;
+ }
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * //
+
+template<class T>
+inline const T& Foam::tmpNrc<T>::operator()() const
+{
+ if (isTmp())
+ {
+ if (!ptr_)
+ {
+ FatalErrorInFunction
+ << typeName() << " deallocated"
+ << abort(FatalError);
+ }
+ }
+
+ // Return const reference
+ return *ptr_;
+}
+
+
+template<class T>
+inline Foam::tmpNrc<T>::operator const T&() const
+{
+ return operator()();
+}
+
+
+template<class T>
+inline T* Foam::tmpNrc<T>::operator->()
+{
+ if (isTmp())
+ {
+ if (!ptr_)
+ {
+ FatalErrorInFunction
+ << typeName() << " deallocated"
+ << abort(FatalError);
+ }
+ }
+ else
+ {
+ FatalErrorInFunction
+ << "Attempt to cast const object to non-const for a " << typeName()
+ << abort(FatalError);
+ }
+
+ return ptr_;
+}
+
+
+template<class T>
+inline const T* Foam::tmpNrc<T>::operator->() const
+{
+ if (isTmp() && !ptr_)
+ {
+ FatalErrorInFunction
+ << typeName() << " deallocated"
+ << abort(FatalError);
+ }
+
+ return ptr_;
+}
+
+
+template<class T>
+inline void Foam::tmpNrc<T>::operator=(T* tPtr)
+{
+ clear();
+
+ if (!tPtr)
+ {
+ FatalErrorInFunction
+ << "Attempted copy of a deallocated " << typeName()
+ << abort(FatalError);
+ }
+
+ type_ = TMP;
+ ptr_ = tPtr;
+}
+
+
+template<class T>
+inline void Foam::tmpNrc<T>::operator=(const tmpNrc<T>& t)
+{
+ clear();
+
+ if (t.isTmp())
+ {
+ type_ = TMP;
+
+ if (!t.ptr_)
+ {
+ FatalErrorInFunction
+ << "Attempted assignment to a deallocated " << typeName()
+ << abort(FatalError);
+ }
+
+ ptr_ = t.ptr_;
+ t.ptr_ = 0;
+ }
+ else
+ {
+ FatalErrorInFunction
+ << "Attempted assignment to a const reference to an object"
+ << " of type " << typeid(T).name()
+ << abort(FatalError);
+ }
+}
+
+
+//- Return the const reference of the non-const reference argument
+template<typename T>
+inline const T& Const(T& t)
+{
+ return t;
+}
+
+
+//- Return the const reference of the non-const rvalue reference argument
+template<typename T>
+inline const T& Const(T&& t)
+{
+ return t;
+}
+
+
+// ************************************************************************* //