SVDCalibrationsBase.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Laura Zani, Eugenio Paoloni                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 * WARNING EXPLOSIVE: PLEASE, WEAR PROTECTIVE SUIT BEFORE USE             *
 **************************************************************************/
 
#pragma once
#include <framework/logging/Logger.h>
 
#include <TObject.h>
#include <vector>
#include <TString.h>
 
namespace Belle2 {
  template < class T  >
  class SVDCalibrationsBase: public TObject {
 
    typedef std::vector< typename T::payloadContainerType > SVDSensor;
 
    typedef std::vector< SVDSensor > SVDLadder;
 
    typedef std::vector< SVDLadder > SVDLayer;
 
    typedef std::vector< SVDLayer > SVD;
 
    SVD calibrations;
 
 
  public:
 
    enum E_side { Vindex = 0 , Uindex = 1 };
 
    SVDCalibrationsBase(typename T::calibrationType defaultT =
                          typename T::calibrationType(),
                        const TString& uniqueID = ""): m_uniqueID(uniqueID)    // Add a string as unique identifier for a given configuration dataset
    {
 
      calibrations.resize(7); // Layers 0 1 2 3 4 5 6
      int laddersOnLayer[] = { 0, 0, 0, 8, 11, 13, 17 };
      for (unsigned int layer = 0 ; layer < calibrations.size() ; layer ++) {
        calibrations[layer].resize(laddersOnLayer[layer]);
        int sensorsOnLadder[] = {0, 0, 0, 3, 4, 5, 6};
        for (unsigned int ladder = 1; ladder < calibrations[layer].size(); ladder ++) {
          calibrations[layer][ladder].resize(sensorsOnLadder[ layer ]);
          for (unsigned int sensor = 1; sensor < calibrations[layer][ladder].size() ; sensor ++) {
            calibrations[layer][ladder][sensor].resize(2);
            T::init(calibrations[layer][ladder][sensor][ Uindex ], layer, ladder, sensor, Uindex ,
                    defaultT);
            T::init(calibrations[layer][ladder][sensor][ Vindex ], layer, ladder, sensor, Vindex ,
                    defaultT);
          }
        }
      }
    }
 
    ~SVDCalibrationsBase() {  };
 
    typename T::calibrationType get(unsigned int layer,
                                    unsigned int ladder,
                                    unsigned int sensor,
                                    unsigned int side,
                                    unsigned int strip) const
    {
      if (calibrations.size() <= layer) {
        B2FATAL("Layers vector is smaller than " << layer);
      }
      const auto& ladders = calibrations[layer];
      if (ladders.size() <= ladder) {
        B2FATAL("Ladders vector is smaller than " << ladder);
      }
      const auto& sensors = ladders[ladder];
      if (sensors.size() <= sensor) {
        B2FATAL("Sensors vector is smaller than " << sensor);
      }
      const auto& sides = sensors[sensor];
      if (sides.size() <= side) {
        B2FATAL("Sides vector is smaller than " << side);
      }
 
      return T::get(sides[side] , strip);
    }
 
    const typename T::calibrationType& getReference(unsigned int layer,
                                                    unsigned int ladder,
                                                    unsigned int sensor,
                                                    unsigned int side,
                                                    unsigned int strip) const
    {
      if (calibrations.size() <= layer) {
        B2FATAL("Layers vector is smaller than " << layer);
      }
      const auto& ladders = calibrations[layer];
      if (ladders.size() <= ladder) {
        B2FATAL("Ladders vector is smaller than " << ladder);
      }
      const auto& sensors = ladders[ladder];
      if (sensors.size() <= sensor) {
        B2FATAL("Sensors vector is smaller than " << sensor);
      }
      const auto& sides = sensors[sensor];
      if (sides.size() <= side) {
        B2FATAL("Sides vector is smaller than " << side);
      }
 
      return T::getReference(sides[side] , strip);
    }
 
    TString get_uniqueID() const {return m_uniqueID;}
 
    void set(unsigned int layer,
             unsigned int ladder,
             unsigned int sensor,
             unsigned int side,
             unsigned int strip,
             typename T::calibrationType value)
    {
      if (calibrations.size() <= layer) {
        B2FATAL("Layers vector is smaller than " << layer);
      }
      auto& ladders = calibrations[layer];
      if (ladders.size() <= ladder) {
        B2FATAL("Ladders vector is smaller than " << ladder);
      }
      auto& sensors = ladders[ladder];
      if (sensors.size() <= sensor) {
        B2FATAL("Sensors vector is smaller than " << sensor);
      }
      auto& sides = sensors[sensor];
      if (sides.size() <= side) {
        B2FATAL("Sides vector is smaller than " << side);
      }
 
      return T::set(sides[side] , strip, value);
    }
 
    E_side sideIndex(bool isU) const
    {
      if (isU)
        return Uindex;
      return Vindex;
      // tertium non datur
    }
 
    typedef T t_perSideContainer; 
  private:
 
    TString m_uniqueID; 
    ClassDef(SVDCalibrationsBase, 2) 
  };
 
}