AlignmentsCalculator.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 DD4HEP_ALIGNMENTSCALCULATOR_H
#define DD4HEP_ALIGNMENTSCALCULATOR_H
 
// Framework include files
#include <DD4hep/Alignments.h>
#include <DD4hep/AlignmentData.h>
#include <DD4hep/ConditionsMap.h>
 
namespace dd4hep {
 
  namespace cond   { class ConditionUpdateContext;  }
  
  namespace align {
 
 
    class AlignmentsCalculator  {
    public:
 
 
      class Result  {
      public:
        size_t computed = 0;
        size_t missing  = 0;
    size_t multiply = 0;
        Result() = default;
        Result(const Result& result) = default;
        Result& operator  =(const Result& result) = default;
        Result& operator +=(const Result& result);
        Result& operator -=(const Result& result);
        size_t total() const { return computed+missing; }
      };
 
 
      class PathOrdering {
      public:
        bool operator()(const DetElement& a, const DetElement& b) const
        { return a.path() < b.path(); }
      };
 
      typedef std::map<DetElement,const Delta*,PathOrdering> OrderedDeltas;
      typedef std::map<Condition::key_type,DetElement>       ExtractContext;
 
 
      class Scanner  {
      public:
        cond::ConditionUpdateContext& context;
        OrderedDeltas&                deltas;
        IOV*                          iov = 0;
      public:
        Scanner() = delete;
        Scanner(cond::ConditionUpdateContext& m, OrderedDeltas& d) : context(m), deltas(d) {}
        Scanner(cond::ConditionUpdateContext& m, OrderedDeltas& d, IOV* i) : context(m), deltas(d), iov(i) {}
        Scanner(cond::ConditionUpdateContext& m, OrderedDeltas&& p) = delete;
        Scanner(Scanner&& copy) = delete;
        Scanner(const Scanner& copy) = delete;
        ~Scanner() = default;
        Scanner& operator=(Scanner&& copy) = delete;
        Scanner& operator=(const Scanner& copy) = delete;
        int operator()(DetElement de, int)  const;
      };
 
    public:
 
      AlignmentsCalculator() = default;
      AlignmentsCalculator(const AlignmentsCalculator& copy) = delete;
      AlignmentsCalculator& operator=(const AlignmentsCalculator& mgr) = delete;
      Result compute(const std::map<DetElement, Delta>& deltas,
                     ConditionsMap& alignments)  const;
      Result compute(const std::map<DetElement, const Delta*>& deltas,
                     ConditionsMap& alignments)  const;
      Result compute(const OrderedDeltas& deltas, ConditionsMap& alignments)  const;
 
      size_t extract_deltas(cond::ConditionUpdateContext& context,
                            OrderedDeltas& deltas,
                            IOV* effective_iov=0)   const;
      size_t extract_deltas(DetElement start,
                            cond::ConditionUpdateContext& ctxt,
                            OrderedDeltas& deltas,
                            IOV* effective_iov=0)   const;
 
      size_t extract_deltas(cond::ConditionUpdateContext& context,
                            ExtractContext& extract_context,
                            OrderedDeltas& deltas,
                            IOV* effective_iov=0)   const;
 
 
      size_t extract_deltas(DetElement start,
                            cond::ConditionUpdateContext& ctxt,
                            ExtractContext& extract_context,
                            OrderedDeltas& deltas,
                            IOV* effective_iov=0)   const;
    };
 
    inline AlignmentsCalculator::Result&
    AlignmentsCalculator::Result::operator +=(const Result& result)  {
      multiply += result.multiply;
      computed += result.computed;
      missing  += result.missing;
      return *this;
    }
    inline AlignmentsCalculator::Result&
    AlignmentsCalculator::Result::operator -=(const Result& result)  {
      multiply -= result.multiply;
      computed -= result.computed;
      missing  -= result.missing;
      return *this;
    }
 
  }       /* End namespace align                  */
}         /* End namespace dd4hep                      */
#endif // DD4HEP_ALIGNMENTSCALCULATOR_H