ConditionsRootPersistency.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation 
//--------------------------------------------------------------------------
// Copyright (C) Organisation europeenne pour la Recherche nucleaire (CERN)
// All rights reserved.
//
// For the licensing terms see $DD4hepINSTALL/LICENSE.
// For the list of contributors see $DD4hepINSTALL/doc/CREDITS.
//
// Author     : M.Frank
//
//==========================================================================
#ifndef DDCOND_CONDITIONSROOTPERSISTENCY_H
#define DDCOND_CONDITIONSROOTPERSISTENCY_H
 
// Framework/ROOT include files
#include "DDCond/ConditionsPool.h"
 
#include "TNamed.h"
class TFile;
 
// C/C++ include files
#include <map>
#include <list>
#include <vector>
#include <memory>
 
 
namespace dd4hep {
 
  namespace cond {
 
    class ConditionsSlice;
    class ConditionsIOVPool;
 
 
    class ConditionsRootPersistency : public TNamed  {
    public:
      typedef std::vector<Condition>                                  pool_type;
      typedef std::pair<std::string, pool_type>                       named_pool_type;
      typedef std::pair<std::string,std::pair<std::pair<std::string,int>,IOV::Key> > iov_key_type;
      typedef std::list<std::pair<iov_key_type, pool_type> >          persistent_type;
 
      persistent_type conditionPools {};
      persistent_type userPools {};
      persistent_type iovPools  {};
      float           duration = 0;
      enum ImportStrategy  {
        IMPORT_ALL             = 1<<0,
        IMPORT_EXACT           = 1<<1,
        IMPORT_CONTAINED       = 1<<2,
        IMPORT_CONTAINED_LOWER = 1<<3,
        IMPORT_CONTAINED_UPPER = 1<<4,
        IMPORT_EDGE_LOWER      = 1<<5,
        IMPORT_EDGE_UPPER      = 1<<6,
        LAST
      };
      size_t _import(ImportStrategy     strategy,
                     persistent_type&   pers,
                     const std::string& id,
                     const std::string& iov_type,
                     const IOV::Key&    iov_key,
                     ConditionsManager  mgr);
 
      void _clear(persistent_type& pool);
      
    public:
      ConditionsRootPersistency(const ConditionsRootPersistency& copy) = delete;
      ConditionsRootPersistency(const std::string& name, const std::string& title="DD4hep conditions container");
      ConditionsRootPersistency();
      virtual ~ConditionsRootPersistency();
      ConditionsRootPersistency& operator=(const ConditionsRootPersistency& copy) = delete;
 
      void clear();
      static TFile* openFile(const std::string& fname);      
      
      size_t add(const std::string& identifier, const IOV& iov, std::vector<Condition>& conditions);
      size_t add(const std::string& identifier, ConditionsPool& pool);
      size_t add(const std::string& identifier, const UserPool& pool);
      size_t add(const std::string& identifier, const ConditionsIOVPool& pool);
 
      static std::unique_ptr<ConditionsRootPersistency> load(TFile* file,const std::string& object);
      
      static std::unique_ptr<ConditionsRootPersistency> load(const std::string& file,const std::string& object)  {
        return load(openFile(file), object);
      }
      
      size_t importIOVPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
      size_t importUserPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
      size_t importConditionsPool(const std::string& id, const std::string& iov_type, ConditionsManager mgr);
 
      size_t importConditionsPool(ImportStrategy     strategy,
                                  const std::string& id,
                                  const std::string& iov_type,
                                  const IOV::Key&    key,
                                  ConditionsManager  mgr);
 
      int save(TFile* file);
      int save(const std::string& file_name);
 
      ClassDef(ConditionsRootPersistency,1);
    };
    
  }        /* End namespace cond                            */
}          /* End namespace dd4hep                          */
#endif // DDCOND_CONDITIONSROOTPERSISTENCY_H