CHANGELOG.md

 Changelog
 =========
 
+v4.4.1
+------
+**Library**
+- Remove m_offset_elmt_id and GetOffsetElmtId which fixed problems in 2D when 
+  quad elements are listed before tri elements (!758)
+- Remove the duplicate output of errorutil (!756)
+- Fix BLAS CMake dependencies (!763)
+- Fix interpolation issue with Lagrange basis functions (!768)
+- Fix issue with average fields not working with different polynomial order
+  fields (!776)
+- Fix rounding of integer parameters (!774)
+- Fix Hdf5 output in FilterFieldConvert (!781)
+- Fixed extreme memory consumption of Interpolator when interpolating from pts
+  to fld or between different meshes (!783)
+- Fix missing entriess in LibUtilities::kPointsTypeStr (!792)
+- Fix compiler warnings with CommDataType (!793)
+- Fix deadlock with HDF5 input (!786)
+- Fix missing entriess in LibUtilities::kPointsTypeStr (!792)
+- Fix compiler warnings with CommDataType (!793)
+- Fix ability to set default implementation in Collections and added an option 
+  to set eNoCollections in FieldConvert as default (!789)
+- Fix performance issue in ProcessIsoContour in relation to memory consumption
+  (!821)
+- Fix performance issue with ExtractPhysToBndElmt (!796)
+- Fix available classes being listed multiple times (!817)
+- Fix overwriting and backup of chk/fld files on slow file systes (!741)
+- Fix Intel compiler warnings (!837)
+- Fixed typo in eIMEXGear part (!854)
+- Added regression tests for IMEXOrder1, IMEXOrder2, IMEXOrder3, MCNAB,
+  IMEXGear, CNAB, 2nd order IMEX-DIRK, 3rd order IMEX-DIRK (!854)
+- Fix DriverAdaptive with second order IMEX (!850)
+- Fix bug due to subtractive cancellation in polylib routines (!778)
+
+**FieldConvert:**
+- Fix issue with field ordering in the interppointdatatofld module (!754)
+- Fix issue with FieldConvert when range flag used (!761)
+- Fix equispacedoutput for 3DH1D with triangles (!787)
+
+**NekMesh**:
+- Fix memory consumption issue with Gmsh output (!747, !762)
+- Rework meshing control so that if possible viewable meshes will be dumped
+  when some part of the system fails (!756)
+- Add manifold meshing option (!756)
+- Fix issue with older rea input files (!765)
+- Fix memory leak in variational optimiser, add small optimisations (!785)
+- Check the dimensionality of the CAD system before running the 2D generator (!780)
+- Fix uninitialised memory bug in Nek5000 input module (!801)
+
+**IncNavierStokesSolver**
+- Fix an initialisation issue when using an additional advective field (!779)
+- Fix MovingBody boundary condition (!852)
+
+**Utilities**
+- Fix vtkToFld missing dependency which prevented compiling with VTK 7.1 (!808)
+
+**Documentation**
+- Added missing details on artificial viscosity and dealising to compressible
+  flow solver user guide (!846)
+
+**Packaging**
+- Added missing package for FieldUtils library (!755)
+
+**ADRSolver:**
+- Fix UnsteadyAdvectionDiffusion with DG (!855)
+
 v4.4.0
 ------
 **Library**:

CONTRIBUTING.md

@@ -44,7 +44,9 @@ project. It's a pretty simple process:
    diff and are not quite ready to merge, use the `[WIP]` tag in the title to
    prevent your code from being accidentally merged.
 5. Put a comment in the MR saying that it's ready to be merged.
-6. Respond to any comments in the code review.
+6. If your branch is a minor fix that could appear in the next patch release,
+   then add the `Proposed patch` label to the merge request.
+7. Respond to any comments in the code review.
 
 ## Submission checklist
 - Did you add regression tests (for fixes) or unit tests and/or normal tests for
@@ -155,6 +157,78 @@ stick to the following process:
 - Once feedback received from the branch author (if necessary) and reviewers are
   happy, the branch will be merged.
 
+## Release branches
+Nektar++ releases are versioned in the standard form `x.y.z` where `x` is a
+major release, `y` a minor release and `z` a patch release:
+
+- major releases are extremely infrequent (on the order of every 2-3 years) and
+  denote major changes in functionality and the API;
+- minor releases occur around twice per year and contain new features with minor
+  API changes;
+- patch releases are targeted on roughly a monthly basis and are intended to
+  fix minor issues in the code.
+
+The repository contains a number of _release branches_ named `release/x.y` for
+each minor release, which are intended to contain **fixes and very minor
+changes** from `master` and which form the next patch release. This allows us to
+use `master` for the next minor release, whilst still having key fixes in patch
+releases.
+
+### Cherry-picking process
+
+Any branches that are marked with the `Proposed patch` label should follow the
+following additional steps to cherry pick commits into the `release/x.y` branch.
+
+1. If the branch is on a remote other than `nektar/nektar`, make sure that's
+   added to your local repository.
+2. On a local terminal, run `git fetch --all` to pull the latest changes. It's
+   important for the commands below that you do this _before_ you merge the
+   branch into `master`.
+3. Merge the branch into master as usual using GitLab.
+4. Switch to the appropriate branch with `git checkout release/x.y` and update
+   with `git pull`.
+5. Now check the list of commits to cherry-pick.
+
+   ```bash
+   git log --oneline --no-merges --reverse origin/master..REMOTE/fix/BRANCHNAME
+   ```
+
+   where `REMOTE` is the remote on which the branch lives and `BRANCHNAME` is
+   the fix branch. If the list is empty, you probably did a `git fetch` after
+   you merged the branch into `master`; in this case use `origin/master^`.
+6. If you're happy with the list (compare to the MR list on the GitLab MR if
+   necessary), cherry-pick the commits with the command:
+
+   ```bash
+   git cherry-pick -x $(git rev-list --no-merges --reverse origin/master..REMOTE/fix/BRANCHNAME)
+   ```
+
+7. It's likely you'll encounter some conflicts, particularly with the
+   `CHANGELOG`. To fix these:
+   - `git status` to see what's broken
+   - Fix appropriately
+   - `git commit -a` to commit your fix
+   - `git cherry-pick --continue`
+8. If everything becomes horribly broken, `git cherry-pick --abort`.
+9. Once you're happy, `git push` to send your changes back to GitLab.
+
+Steps 5 and 6 can be simplified by creating a script
+```bash
+#!/bin/bash
+src=$1
+
+logopts="--oneline --no-merges --reverse"
+commits=`git log $logopts master..$1 | cut -f 1 -d " " | xargs`
+
+echo "Will cherry-pick the following commits: $commits"
+echo "Press ENTER to continue..."
+read
+
+cherryopts="-x --allow-empty --allow-empty-message"
+git cherry-pick $cherryopts $commits
+```
+which accepts the name of the source branch as the sole argument.
+
 ## Formatting guidelines
 Nektar++ uses C++, a language notorious for being easy to make obtuse and
 difficult to follow code. To hopefully alleviate this problem, there are a

VERSION

-4.4.0
+4.4.1

cmake/ThirdPartyFFTW.cmake

@@ -10,13 +10,14 @@ OPTION(NEKTAR_USE_FFTW
     "Use FFTW routines for performing the Fast Fourier Transform." OFF)
 
 IF (NEKTAR_USE_FFTW)
-    # Set some common FFTW search paths.
+    # Set some common FFTW search paths for the library.
     SET(FFTW_SEARCH_PATHS $ENV{LD_LIBRARY_PATH} $ENV{FFTW_HOME}/lib)
     FIND_LIBRARY(FFTW_LIBRARY NAMES fftw3 fftw3f PATHS ${FFTW_SEARCH_PATHS})
 
-    IF (FFTW_LIBRARY)
-        GET_FILENAME_COMPONENT(FFTW_PATH ${FFTW_LIBRARY} PATH)
-        SET(FFTW_INCLUDE_DIR ${FFTW_PATH}/../include CACHE FILEPATH "FFTW include directory.")
+    FIND_PATH(FFTW_INCLUDE_DIR NAMES fftw3.h CACHE FILEPATH 
+        "FFTW include directory.")
+
+    IF (FFTW_LIBRARY AND FFTW_INCLUDE_DIR)
         SET(BUILD_FFTW OFF)
     ELSE()
         SET(BUILD_FFTW ON)
@@ -55,9 +56,18 @@ IF (NEKTAR_USE_FFTW)
         MESSAGE(STATUS "Found FFTW: ${FFTW_LIBRARY}")
         SET(FFTW_CONFIG_INCLUDE_DIR ${FFTW_INCLUDE_DIR})
     ENDIF()
+
+    # Test if FFTW path is a system path. Only add to include path if not an
+    # implicitly defined CXX include path (due to GCC 6.x now providing its own
+    # version of some C header files and -isystem reorders include paths).
+    GET_FILENAME_COMPONENT(X ${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES} ABSOLUTE)
+    GET_FILENAME_COMPONENT(Y ${FFTW_INCLUDE_DIR} ABSOLUTE)
+    IF (NOT Y MATCHES ".*${X}.*")
+        INCLUDE_DIRECTORIES(SYSTEM ${FFTW_INCLUDE_DIR})
+    ENDIF()
+
+    MARK_AS_ADVANCED(FFTW_LIBRARY)
+    MARK_AS_ADVANCED(FFTW_INCLUDE_DIR)
 ENDIF( NEKTAR_USE_FFTW )
 
-INCLUDE_DIRECTORIES(SYSTEM ${FFTW_INCLUDE_DIR})
 
-MARK_AS_ADVANCED(FFTW_LIBRARY)
-MARK_AS_ADVANCED(FFTW_INCLUDE_DIR)

docs/doxygen/Doxyfile.in

@@ -757,6 +757,7 @@ INPUT                  = @CMAKE_SOURCE_DIR@/docs/doxygen/ \
                          @CMAKE_SOURCE_DIR@/library/LibUtilities/ \
                          @CMAKE_SOURCE_DIR@/library/StdRegions/ \
                          @CMAKE_SOURCE_DIR@/library/SpatialDomains/ \
+                         @CMAKE_SOURCE_DIR@/library/Collections/ \
                          @CMAKE_SOURCE_DIR@/library/LocalRegions/ \
                          @CMAKE_SOURCE_DIR@/library/MultiRegions/ \
                          @CMAKE_SOURCE_DIR@/library/GlobalMapping/ \

docs/user-guide/solvers/compressible-flow.tex

@@ -449,6 +449,24 @@ For the non-smooth artificial viscosity model the added artificial viscosity is
       \end{array} 
     \right.
 \end{equation}
+
+To enable the non-smooth viscosity model, the following line has to be added to the \inltt{SOLVERINFO} section:
+\begin{lstlisting}[style=XmlStyle]
+ <SOLVERINFO>
+<I PROPERTY="ShockCaptureType"      VALUE="NonSmooth"               />
+ <SOLVERINFO>
+\end{lstlisting}
+The diffusivity is controlled by the following parameters:
+\begin{lstlisting}[style=XmlStyle]
+<PARAMETERS>
+<P> Skappa 	 	= -1.3                     </P>
+<P> Kappa 	 	= 0.2                      </P> 
+<P> mu0 	 	= 1.0                      </P>
+</PARAMETERS>
+\end{lstlisting}
+where mu0 is the maximum values for the viscosity coefficient, 
+Kappa is half of the width of the transition interval and Skappa is 
+the value of the centre of the interval.
 \begin{figure}[!htbp]
 \begin{center}
 \includegraphics[width = 0.47 \textwidth]{img/Mach_P4.pdf}
@@ -457,6 +475,7 @@ For the non-smooth artificial viscosity model the added artificial viscosity is
 \label{fig:}
 \end{center}
 \end{figure}
+
 \subsubsection{Smooth artificial viscosity model}
 For the smooth artificial viscosity model an extra PDE for the artificial viscosity is appended to the Euler system
 \begin{equation}\label{eq:eulerplusvis}\begin{split}
@@ -511,5 +530,52 @@ The polynomial order in each element can be adjusted based on the sensor value t
     \right.
 \end{equation}
 For now, the threshold values $s_e$, $s_{ds}$, $s_{sm}$ and $s_{fl}$ are determined empirically by looking at the sensor distribution in the domain. Once these values are set, two .txt files are outputted, one that has the composites called VariablePComposites.txt and one with the expansions called VariablePExpansions.txt. These values have to copied into a new .xml file to create the adapted mesh.
+\subsection{De-Aliasing Techniques}
+Aliasing effects, arising as a consequence of the nonlinearity of the 
+underlying problem, need to be address to stabilise the simulations. Aliasing 
+appears when nonlinear quantities are calculated at an insufficient number of 
+quadrature points. We can identify two types of nonlinearities: 
+\begin{itemize}
+\item PDE nonlinearities, related to the nonlinear and quasi-linear fluxes.
+\item Geometrical nonlinearities, related to the deformed/curves meshes.
+\end{itemize}
+We consider two de-aliasing strategies based on the concept of consistent integration:
+
+\begin{itemize}
+\item Local dealiasing: It only targets the PDE-aliasing sources, applying a consistent integration of them locally. 
+\item Global dealiasing: It targets both the PDE and the geometrical-aliasing sources. It requires a richer quadrature order to consistently integrate the nonlinear fluxes, the geometric factors, the mass matrix and the boundary term. 
+\end{itemize}
+
+Since Nektar++ tackles separately the PDE and geometric aliasing during the 
+projection and solution of the equations, to consistently 
+integrate all the nonlinearities in the compressible
+NavierStokes equations, the quadrature points should 
+be selected based on the maximum order of the nonlinearities: 
+\begin{equation}
+Q_{min}= P_{exp}+\frac{max(2P_{exp},P_{geom})}{2} + \frac{3}{2}
+\end{equation}
+
+where $Q_{min}$ is the minimum required number of quadrature 
+points to exactly integrate the highest-degree of nonlinearity,
+$P_{exp}$ being the order of the polynomial expansion and $P_{geom}$
+being the geometric order of the mesh. Bear in mind thatwe are 
+using a discontinuous discretisation, meaning that aliasing
+effect are not fully controlled, since the boundary terms 
+introduce non-polynomial functions into the problem.
 
+To enable the global de-aliasing technique, modify the number of quadrature
+points by:
+
+\begin{lstlisting}[style=XmlStyle]
+<E COMPOSITE="[101]"
+   BASISTYPE="Modified_A,Modified_A"
+   NUMMODES="7,7"
+   POINTSTYPE="GaussLobattoLegendre,GaussLobattoLegendre"
+   NUMPOINTS="14,14"
+   FIELDS="rho,rhou,rhov,E" 
+/> 
+\end{lstlisting}
 
+where \inltt{NUMMODES} corresponds to $P$+1, where $P$ is the order of the polynomial
+used to approximate the solution. \inltt{NUMPOINTS} specifies the number of quadrature 
+points.

docs/user-guide/utilities/fieldconvert.tex

@@ -490,7 +490,7 @@ In order to interpolate 1D data to a $n$D field, specify the matching coordinate
 the output field using the \inltt{interpcoord} argument:
 %
 \begin{lstlisting}[style=BashInputStyle]
-FieldConvert -m interppointdatatofld:interppointdatatofld=1 3D-file1.xml \
+FieldConvert -m interppointdatatofld:interpcoord=1 3D-file1.xml \
 		1D-file1.pts 3D-file1.fld
 \end{lstlisting}
 %

library/Collections/CollectionOptimisation.cpp

@@ -84,11 +84,16 @@ CollectionOptimisation::CollectionOptimisation(
     {
         for (it2 = elTypes.begin(); it2 != elTypes.end(); ++it2)
         {
-            defaultsPhysDeriv [ElmtOrder(it2->second, -1)] = eNoCollection;
+            // For 1<=N<=5 use StdMat otherwise IterPerExp or given default type
             for (int i = 1; i < 5; ++i)
             {
                 defaults[ElmtOrder(it2->second, i)] = eStdMat;
             }
+
+            // For 1<=N<=3 use SumFac otherwise NoCollection. Note that
+            // default is not currently overwritten by given default
+            // type
+            defaultsPhysDeriv [ElmtOrder(it2->second, -1)] = eNoCollection;
             for (int i = 1; i < 3; ++i)
             {
                 defaultsPhysDeriv[ElmtOrder(it2->second, i)] = eSumFac;
@@ -157,6 +162,7 @@ CollectionOptimisation::CollectionOptimisation(
                     ASSERTL0(i != Collections::SIZE_ImplementationType,
                          "Unknown default collection scheme: "+collinfo);
 
+                    defaults.clear();
                     // Override default types
                     for (it2 = elTypes.begin(); it2 != elTypes.end(); ++it2)
                     {

library/Demos/LibUtilities/CMakeLists.txt

@@ -50,3 +50,12 @@ IF(NEKTAR_USE_HDF5)
     ADD_NEKTAR_EXECUTABLE(FieldIOBenchmarker demos FieldIOBenchmarkerSources)
     TARGET_LINK_LIBRARIES(FieldIOBenchmarker LibUtilities)
 ENDIF()
+
+ADD_NEKTAR_TEST(TimeIntegrationDemoIMEXGear)
+ADD_NEKTAR_TEST(TimeIntegrationDemoIMEXOrder1)
+ADD_NEKTAR_TEST(TimeIntegrationDemoIMEXOrder2)
+ADD_NEKTAR_TEST(TimeIntegrationDemoIMEXOrder3)
+ADD_NEKTAR_TEST(TimeIntegrationDemoDIRKIMEXOrder2)
+ADD_NEKTAR_TEST(TimeIntegrationDemoDIRKIMEXOrder3)
+ADD_NEKTAR_TEST(TimeIntegrationDemoCNAB)
+ADD_NEKTAR_TEST(TimeIntegrationDemoMCNAB)

library/Demos/LibUtilities/Tests/TimeIntegrationDemoCNAB.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 7</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.10135</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoDIRKIMEXOrder2.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 4</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.0616905</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoDIRKIMEXOrder3.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 5</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.061634</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoIMEXGear.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 6</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.315262</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoIMEXOrder1.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 1</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.224678</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoIMEXOrder2.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 2</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.0798986</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoIMEXOrder3.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 3</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.0610636</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/LibUtilities/Tests/TimeIntegrationDemoMCNAB.tst

+<?xml version="1.0" encoding="utf-8" ?>
+<test>
+    <description>Test for time integration schemes</description>
+    <executable>TimeIntegrationDemo</executable>
+    <parameters>--Npoints 100 --Ntimesteps 100 --NTimeIntegrationMethod 8</parameters>
+    <metrics>
+        <metric type="L2" id="1">
+            <value tolerance="1e-12">0.134315</value>
+        </metric>
+    </metrics>
+</test>

library/Demos/MultiRegions/Tests/Helmholtz3D_CG_Prism_Deformed.tst

@@ -9,10 +9,10 @@
 
     <metrics>
         <metric type="L2" id="1">
-            <value tolerance="1e-9">3.35253e-06</value>
+            <value tolerance="1e-9">1.13842e-05</value>
         </metric>
         <metric type="Linf" id="2">
-            <value tolerance="1e-9">4.45606e-05</value>
+            <value tolerance="1e-9">7.59576e-05</value>
         </metric>
     </metrics>
 </test>

library/FieldUtils/Field.hpp

@@ -177,7 +177,8 @@ struct Field
                     Exp2DH1 =
                         MemoryManager<MultiRegions::ExpList2DHomogeneous1D>::
                             AllocateSharedPtr(m_session, Bkey, ly, m_useFFT,
-                                              dealiasing, m_graph);
+                                              dealiasing, m_graph,
+                                              Collections::eNoCollection);
                     exp = Exp2DH1;
                 }
                 else if (NumHomogeneousDir == 2)
@@ -223,7 +224,8 @@ struct Field
                             MultiRegions::ContField3DHomogeneous2D>::
                             AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
                                               m_useFFT, dealiasing, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              Collections::eNoCollection);
                     }
                     else if (m_declareExpansionAsDisContField)
                     {
@@ -231,14 +233,16 @@ struct Field
                             MultiRegions::DisContField3DHomogeneous2D>::
                             AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
                                               m_useFFT, dealiasing, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              Collections::eNoCollection);
                     }
                     else
                     {
                         Exp3DH2 = MemoryManager<
                             MultiRegions::ExpList3DHomogeneous2D>::
                             AllocateSharedPtr(m_session, BkeyY, BkeyZ, ly, lz,
-                                              m_useFFT, dealiasing, m_graph);
+                                              m_useFFT, dealiasing, m_graph,
+                                              Collections::eNoCollection);
                     }
 
                     exp = Exp3DH2;
@@ -251,18 +255,23 @@ struct Field
                     {
                         Exp1D = MemoryManager<MultiRegions::ContField1D>::
                             AllocateSharedPtr(m_session, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              Collections::eNoCollection);
                     }
                     else if (m_declareExpansionAsDisContField)
                     {
                         Exp1D = MemoryManager<MultiRegions::DisContField1D>::
                             AllocateSharedPtr(m_session, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              true,
+                                              Collections::eNoCollection);
                     }
                     else
                     {
                         Exp1D = MemoryManager<MultiRegions::ExpList1D>::
-                            AllocateSharedPtr(m_session, m_graph);
+                            AllocateSharedPtr(m_session, m_graph,
+                                              true,
+                                              Collections::eNoCollection);
                     }
 
                     exp = Exp1D;
@@ -327,7 +336,8 @@ struct Field
                             MultiRegions::ContField3DHomogeneous1D>::
                             AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
                                               dealiasing, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              Collections::eNoCollection);
                     }
                     else if (m_declareExpansionAsDisContField)
                     {
@@ -335,14 +345,17 @@ struct Field
                             MultiRegions::DisContField3DHomogeneous1D>::
                             AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
                                               dealiasing, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              Collections::eNoCollection);
                     }
                     else
                     {
                         Exp3DH1 = MemoryManager<
                             MultiRegions::ExpList3DHomogeneous1D>::
                             AllocateSharedPtr(m_session, Bkey, lz, m_useFFT,
-                                              dealiasing, m_graph);
+                                              dealiasing, m_graph,
+                                              "DefaultVar",
+                                              Collections::eNoCollection);
                     }
                     exp = Exp3DH1;
                 }
@@ -354,18 +367,25 @@ struct Field
                     {
                         Exp2D = MemoryManager<MultiRegions::ContField2D>::
                             AllocateSharedPtr(m_session, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              true,false,
+                                              Collections::eNoCollection);
                     }
                     else if (m_declareExpansionAsDisContField)
                     {
                         Exp2D = MemoryManager<MultiRegions::DisContField2D>::
                             AllocateSharedPtr(m_session, m_graph,
-                                              m_session->GetVariable(0));
+                                              m_session->GetVariable(0),
+                                              true,true,
+                                              Collections::eNoCollection);
                     }
                     else
                     {
                         Exp2D = MemoryManager<MultiRegions::ExpList2D>::
-                            AllocateSharedPtr(m_session, m_graph);
+                            AllocateSharedPtr(m_session, m_graph,
+                                              true, 
+                                              "DefaultVar",
+                                              Collections::eNoCollection);
                     }
 
                     exp = Exp2D;
@@ -380,19 +400,26 @@ struct Field
                 {
                     Exp3D = MemoryManager<MultiRegions::ContField3D>::
                         AllocateSharedPtr(m_session, m_graph,
-                                          m_session->GetVariable(0));
+                                          m_session->GetVariable(0),
+                                          false,
+                                          Collections::eNoCollection);
                 }
                 else if (m_declareExpansionAsDisContField)
                 {
                     Exp3D = MemoryManager<MultiRegions::DisContField3D>::
                         AllocateSharedPtr(m_session, m_graph,
-                                          m_session->GetVariable(0));
+                                          m_session->GetVariable(0),
+                                          true,
+                                          Collections::eNoCollection);
                 }
                 else
                 {
                     Exp3D = MemoryManager<
-                        MultiRegions::ExpList3D>::AllocateSharedPtr(m_session,
-                                                                    m_graph);
+                        MultiRegions::ExpList3D>::AllocateSharedPtr(
+                                               m_session,
+                                               m_graph,
+                                               "DefaultVar",
+                                               Collections::eNoCollection);
                 }
 
                 exp = Exp3D;