ConditionsTreePersistency.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_CONDITIONSTREEPERSISTENCY_H
#define DDCOND_CONDITIONSTREEPERSISTENCY_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 {
 
    /*
     *   event (iov)
     *       |
     *       |
     *       |           Link attribute:
     *       |           (priority,tag-id)
     *       V            0..*                       valid for mutiple conditions
     *   global tag ---------------->  condition tag (iov,version,pool-id)
     *   (named,iov)                       | 1       [cached, # of consecutive iov]
     *   [in memory]                       |
     *                                     |
     *                                     |
     *                                     V 0..1
     *                               conditions pool (pool-id)
     *                                     |         [DDCond cache/management]
     *                                     |
     *                                     |
     *                                     |
     *                                     V 0..*
     *                                 condition
     *                                                              
     *
     */
    
    class ConditionsTag  {
    public:
      std::string name;
      IOV         iov{0};
      int         version = -1;
      int         collectionID = -1;
      ~ConditionsTag() = default;
      ConditionsTag() = default;
      ConditionsTag(const ConditionsTag& copy) =  default;
      ConditionsTag& operator=(const ConditionsTag& copy) =  default;
    };
 
    class GlobalTag  {
    public:
      std::string       name;
      IOV               iov{0};
 
 
      std::map<std::pair<int,int>, int>  tags;
 
 
      ~GlobalTag()   = default;
      GlobalTag()    = default;
      GlobalTag(const GlobalTag& copy) =  default;
      GlobalTag& operator=(const GlobalTag& copy) =  default;
    };
 
    class ConditionsSlice;
    class ConditionsIOVPool;
 
 
    class ConditionsTreePersistency : 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 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:
      ConditionsTreePersistency(const ConditionsTreePersistency& copy) = delete;
      ConditionsTreePersistency(const std::string& name, const std::string& title="DD4hep conditions container");
      ConditionsTreePersistency();
      virtual ~ConditionsTreePersistency();
      ConditionsTreePersistency& operator=(const ConditionsTreePersistency& copy) = delete;
 
      void clear();
      static TFile* openFile(const std::string& fname);      
      
      size_t add(const std::string& tag, const IOV& iov, std::vector<Condition>& conditions);
      size_t add(const std::string& tag, ConditionsPool& pool);
      size_t add(const std::string& tag, const ConditionsIOVPool& pool);
 
      
      static std::unique_ptr<ConditionsTreePersistency> load(TFile* file,const std::string& object);
      
      static std::unique_ptr<ConditionsTreePersistency> 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 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(ConditionsTreePersistency,1);
    };
    
  }        /* End namespace cond                            */
}          /* End namespace dd4hep                          */
#endif // DDCOND_CONDITIONSTREEPERSISTENCY_H