Database.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include "MeshSweepData.h"
#include "ParticleIdentifier.h"
#include "tarch/la/Vector.h"
#include "tarch/multicore/MultiReadSingleWriteSemaphore.h"
 
#include <functional> // needed for std::less
#include <map>
#include <vector>
 
 
#if !defined(AssignmentChecks) and !defined(noAssignmentChecks) \
  and PeanoDebug > 0
#define AssignmentChecks
#endif
 
 
namespace toolbox {
  namespace particles {
    namespace assignmentchecks {
      namespace internal {
 
        using ParticleEvents = std::vector<Event>;
 
        class Database {
 
          // Singleton-related stuff first, actual class content later.
        public:
          static Database& getInstance() {
 
            static Database _database;
            return _database;
          }
 
          // C++ 11 way of doing things. Explicitly delete the methods
          // we don't want.
          Database(const Database&)       = delete;
          void operator=(const Database&) = delete;
 
        private:
          // Make constructor private so nobody can make one by accident.
          Database() {
            setMaxParticleSnapshotsToKeepTrackOf(8);
            this->reset();
          };
 
          tarch::multicore::MultiReadSingleWriteSemaphore _semaphore;
 
          std::vector<MeshSweepData> _meshSweepData;
          int                        _currentMeshSweepIndex;
 
          // tell the map to use std::less<> as comparator instead of the
          // default std::less<key>. std::less<> invokes the `<` operator.
          // We want that to be able to use our bespoke `<` operator
          // for different search and ID key identifier objects.
          std::map<ParticleIdentifier, ParticleEvents, std::less<>> _data;
 
          size_t _maxParticleEventsToKeepTrackOf;
 
        public:
          static constexpr int AnyTree = -1;
 
          void setMaxParticleSnapshotsToKeepTrackOf(const size_t n);
 
          void startMeshSweep(const std::string& meshSweepName);
 
          ParticleEvents getParticleHistory(const ParticleIdentifier& identifier
          );
 
          std::string particleHistory(const ParticleIdentifier& identifier);
 
          std::string lastMeshSweepSnapshot();
 
          int getTotalParticleEntries(const ParticleIdentifier& identifier);
 
          int getNumberOfSnapshots() const;
 
          Event addEvent(ParticleIdentifier identifier, Event& event);
 
          void replaceEvent(
            ParticleIdentifier identifier,
            Event&             oldEvent,
            Event&             newEvent
          );
 
          void shiftIdentifierVertexInd(
            ParticleIdentifier&                       identifier,
            tarch::la::Vector<Dimensions, long long>& newVertexInd,
            const int                                 newVertexDepth
          );
 
          std::string toString();
 
          void reset();
 
          size_t getCurrentMeshSweepIndex() const;
 
          int getNumberOfTracedParticles() const;
 
          std::vector<MeshSweepData>& getMeshSweepData();
 
          std::string sweepHistory();
 
          void eliminateExistingParticles();
 
          Event getPreviousEvent(
            ParticleEvents& particleHistory,
            int             spacetreeId,
            size_t          nFirstEventsToSkip = 0
          );
 
        }; // class Database
      }    // namespace internal
    }      // namespace assignmentchecks
  }        // namespace particles
} // namespace toolbox