GGSRootFileService.h

Go to the documentation of this file.

/*
 * GGSRootFileService.h
 *
 *  Created on: 03 Jun 2011
 *      Author: Nicola Mori
 */

#ifndef GGSROOTFILESERVICE_H_
#define GGSROOTFILESERVICE_H_

#include <list>
#include <vector>

#include "TFile.h"
#include "TObjString.h"
#include "TString.h"
#include "TTree.h"

#include "G4Run.hh"
#include "G4VPhysicalVolume.hh"

#include "boost/filesystem.hpp"
#include "boost/unordered_map.hpp"
#include <boost/functional/hash.hpp>
using namespace boost::filesystem;

#include "montecarlo/dataobjs/GGSTSimInfo.h"
#include "montecarlo/useractions/manager/GGSUserActionsManager.h"

class GGSRootFileService {

public:
  static GGSRootFileService &GetInstance();

  ~GGSRootFileService();

  TFile *GetFileForThisRun(const path &baseName, const G4Run *run);

  void CloseFileForThisRun(const path &baseName);

  TTree *GetDefaultTree(TFile *file);

  void SetSuffix(const std::string &suffix) { _suffix = suffix; }

  void SetDefaultFileBase(const path &newFileBase) { _defaultOutBase = newFileBase; }

  int StoreVolume(TFile *filePtr, const std::string &detector, const G4VPhysicalVolume *volume,
                  const G4ThreeVector &position, int id);

  void SetSimInfo(const GGSTSimInfo &simInfo) { _simInfo = simInfo; }

private:
  GGSRootFileService();

  path _GetAbsolutePath(const path &baseName);
  TString _AppendSuffixAndExt(const path &baseName, const G4Run *run);

  friend class GGSUserActionsManager;
  void _FillDefaultEventsTrees(); // Called by GGSUserActionsManager at end of event

  // Define the key class for indexing the transient volume index...
  struct VolumeKey {
    std::string name;
    const G4VPhysicalVolume *physVol;
    G4ThreeVector position;

    VolumeKey(const std::string &volName, const G4VPhysicalVolume *physVolPtr, const G4ThreeVector &pos)
        : name(volName), physVol(physVolPtr), position(pos) {}
    bool operator==(const VolumeKey &rhs) const {
      return (name == rhs.name && physVol == rhs.physVol && position == rhs.position);
    }
  };
  // ... its hash function...
  friend std::size_t hash_value(const VolumeKey &key) {
    std::size_t seed = 0;
    boost::hash_combine(seed, key.name);
    boost::hash_combine(seed, key.physVol);
    boost::hash_combine(seed, key.position[0]);
    boost::hash_combine(seed, key.position[1]);
    boost::hash_combine(seed, key.position[2]);
    return seed;
  }
  // ... and the transient index itself.
  typedef boost::unordered_map<VolumeKey, G4int, boost::hash<VolumeKey>>
      HitVolMap; // <volume name, position in the GGSTHitDetInfo.volumes array>
  typedef std::list<std::pair<std::string, HitVolMap>> HitDetMap; // <detector name, index of volumes>

  // Define the class to store the info about the output file...
  struct FileInfo {
    path absBaseName;
    TFile *filePtr;
    TTree *defaultEventsTree;
    int nRequests;
    HitDetMap *detectorsMap;      // Transient index structure for fast searching during event processing.
    TClonesArray *detectorsArray; // Persistent detectors objects to be saved in this file

    FileInfo();
  };
  // ... the file info container class...
  typedef std::list<FileInfo> FileInfoContainer;
  // ... and the container itself.
  FileInfoContainer _files;

  TString _suffix;
  path _defaultOutBase;

  GGSTSimInfo _simInfo;

  // Variables used for performance in StoreVolume
  TFile *_currVolStorageFile;
  std::string _currDetVolName;
  FileInfoContainer::iterator _currVolStorageFileInfo;
};

#endif /* GGSROOTFILESERVICE_H_ */