Shim class for loading G3SuperTimestream objects from disk

This PR is the first step in integrating the G3SuperTimestream class used by the
Simons Observatory team into the core library.  This class is a very thin
wrapper around the core G3TimestreamMap class.  It is designed only to load
G3SuperTimestream objects from G3 files on disk for immediate conversion to
G3TimestreamMap objects.  It is also not exposed to the public or python API.

Author: arahlin

core/CMakeLists.txt

@@ -10,7 +10,7 @@ add_spt3g_library(core SHARED
 	src/G3Pipeline.cxx src/G3Writer.cxx src/G3Reader.cxx
 	src/G3InfiniteSource.cxx src/G3Logging.cxx src/G3PrintfLogger.cxx
 	src/G3Data.cxx src/G3Vector.cxx src/G3Map.cxx src/G3Timestream.cxx
-        src/G3Timesample.cxx
+        src/G3Timesample.cxx src/G3SuperTimestream.cxx
 	src/G3TriggeredBuilder.cxx src/G3MultiFileWriter.cxx src/dataio.cxx
 	src/compression.cxx src/crc32.c ${CORE_EXTRA_SRCS}
 	src/G3NetworkSender.cxx src/G3SyslogLogger.cxx
@@ -40,6 +40,11 @@ if(FLAC_FOUND)
 	target_link_libraries(core PRIVATE FLAC::FLAC)
 endif()
 
+find_package(OpenMP)
+if(OpenMP_FOUND)
+	target_link_libraries(core PRIVATE OpenMP::OpenMP_CXX)
+endif()
+
 # Link against Z library
 if(NOT DEFINED WITH_ZLIB)
 	set(WITH_ZLIB TRUE CACHE BOOL "Enable gzip fie compression")

core/include/core/G3Timestream.h

@@ -245,25 +245,32 @@ class G3TimestreamMap : public G3FrameObject,
 	                                   G3Time start, G3Time stop,
 	                                   G3Timestream::TimestreamUnits units=G3Timestream::None,
 	                                   int compression_level=0){
-		if(!std::is_sorted(keys.begin(), keys.end()))
+		G3TimestreamMap map;
+		map.FromBuffer(keys, n_samples, data, start, stop, units, compression_level);
+		return map;
+	}
+
+	template<typename SampleType>
+	void FromBuffer(const std::vector<std::string>& keys, std::size_t n_samples,
+	    std::shared_ptr<SampleType[]> data, G3Time start, G3Time stop,
+	    G3Timestream::TimestreamUnits units=G3Timestream::None, int compression_level=0) {
+		if (!std::is_sorted(keys.begin(), keys.end()))
 			throw std::runtime_error("G3TimestreamMap::MakeCompact: keys must be sorted");
 		const auto data_type=G3Timestream::TimeStreamTypeResolver<SampleType>::type_tag;
-		G3TimestreamMap map;
-		std::size_t offset=0;
-		for(const auto& key : keys){
-			auto ts=std::make_shared<G3Timestream>(0);
-			ts->start=start;
-			ts->stop=stop;
-			ts->units=units;
-			ts->use_flac_=compression_level;
-			ts->root_data_ref_=data;
-			ts->data_=data.get()+offset;
-			ts->data_type_=data_type;
-			ts->len_=n_samples;
-			map.emplace(key, std::move(ts));
-			offset+=n_samples;
+		std::size_t offset = 0;
+		for (const auto& key : keys) {
+			auto ts = std::make_shared<G3Timestream>(0);
+			ts->start = start;
+			ts->stop = stop;
+			ts->units = units;
+			ts->use_flac_ = compression_level;
+			ts->root_data_ref_ = data;
+			ts->data_ = data.get() + offset;
+			ts->data_type_ = data_type;
+			ts->len_ = n_samples;
+			emplace(key, std::move(ts));
+			offset += n_samples;
 		}
-		return map;
 	}
 
 	template <class A> void serialize(A &ar, unsigned v);

core/src/G3Frame.cxx

@@ -1,6 +1,7 @@
 #include <G3Frame.h>
 #include <G3Data.h>
 #include <G3Quat.h>
+#include "G3SuperTimestream.h"
 #include <serialization.h>
 #include <pybindings.h>
 
@@ -358,6 +359,12 @@ void G3Frame::blob_decode(struct blob_container &blob)
 	G3BufferInputStream is(*blob.blob);
 	cereal::PortableBinaryInputArchive item_ar(is);
 	item_ar >> make_nvp("val", ptr);
+
+	// Convert to public type
+	auto v = std::dynamic_pointer_cast<G3SuperTimestream>(ptr);
+	if (!!v)
+		ptr = std::make_shared<G3TimestreamMap>(*v);
+
 	blob.frameobject = ptr;
 
 	// Drop really big (> 128 MB) blobs at decode time. The savings