SiPMArray.cc

Go to the documentation of this file.

#include <mdet/SiPMArray.h>

#include <mdet/SiPM.h>
#include <mdet/MHierarchyInfo.h>
//
#include <utl/ErrorLogger.h>
#include <utl/RandomEngine.h>
//
#include <fwk/RandomEngineRegistry.h>
//
#include <CLHEP/Random/RandFlat.h>
//
#include <cmath>
#include <algorithm>
#include <numeric>
#include <sstream>
//
#include <boost/algorithm/minmax_element.hpp>
#include <boost/lambda/lambda.hpp>

namespace { // unnamed namespace with local helper stuff.
  struct SiPMEq
  {
    SiPMEq(const mdet::SiPM& p) : fSiPM(p)
    { }
    bool operator()(const mdet::SiPM* const o) const {
       /*
        * Same object (equal addresses).
        * Here we're relying on the fact that there
        * isn't a subverted overload for operator&
        * among SiPMs and then that we're calling the
        * built-in one which gives the object-address.
        *
        * Boost's utility AddressOf could have been used
        * but it seems that using them would have been too
        * fancy more than a real concern: don't overload
        * operator&, please (at least for a mdet::SiPM).
        */
      if (o == &fSiPM)
        return true;
      // Id has to be equal
      return o->GetId() == fSiPM.GetId() &&
      // and then also within the hierarchy.
        o->GetIdsMap() == fSiPM.GetIdsMap();
    }
    const mdet::SiPM& fSiPM;
  };

}

namespace mdet {

  const char* const
  SiPMArray::kComponentName = MHierarchyInfo::kComponentsNames[9];

  const char* const
  SiPMArray::kComponentId   = MHierarchyInfo::kComponentsIds[9];


  SiPMArray::SiPMGroup::SizeType
  SiPMArray::GetRows()
    const
  {
    SiPMGroup::SizeType tot  = fSiPMs.GetNumberOfComponents();
    // Work with square SiPMArrays.
    // To the able to work with rectangular one another datum is needed in the config,
    // for instance the number of rows.
    SiPMGroup::SizeType root = static_cast<SiPMGroup::SizeType>(std::sqrt(double(tot)));
    if (tot != root*root) {
      std::ostringstream ss;
      ss << "The total number of SiPMs is not a perfect square number in ";
      AddIdMessage(ss);
      ss << ".";
      ERROR(ss);
    }
    return root;
  }

  SiPMArray::SiPMGroup::SizeType
  SiPMArray::GetCols()
    const
  {
    SiPMGroup::SizeType tot  = fSiPMs.GetNumberOfComponents();
    return tot / GetRows();
  }

  const Module&
  SiPMArray::GetModule()
    const
  {
    return fModule;
  }

  SiPMArray::SiPMArray
    (int pId, const det::VManager::IndexMap& parentMap, const Module& parent) :
      MDetectorComponent<SiPMArray>::Type(pId, parentMap),
      fSiPMs(*this),
      fModule(parent)
  {
    fSiPMs.Update(GetIdsMap());
    InitSiPMs();
  }

  void
  SiPMArray::InitSiPMs()
  {
    if (fSiPMs.GetNumberOfComponents()) {
      // Take the minimun element to make everything relative to this id.
      /*
       * Something like this can't be done cause the iterators doesn't model
       * asignable concept.
       *
       *  std::min_element(SiPMsBegin(), SiPMsEnd(),
       *  boost::bind(&SiPM::GetId, _1) < boost::bind(&SiPM::GetId, _2))->GetId()
       *./det/ComponentGroup.h:108: error: non-static reference member
       * 'const det::ComponentGroup<mdet::SiPMArray, mdet::SiPM, det::ParentCreator,
       * mdet::MManagerProvider>&
       * det::ComponentGroup<mdet::SiPMArray, mdet::SiPM, det::ParentCreator, mdet::MManagerProvider>
       *  ::InternalConstFunctor::fContainer', can't use default assignment operator
       */
      { // scope this!
        SiPMConstIterator i = SiPMsBegin();
        SiPMConstIterator e = SiPMsEnd();
        // It's know that there's one at least.
        fFirstIdSiPMArray          = i->GetId(); // Note that we're initializing the member variable.
        for (++i; i != e; ++i)
          fFirstIdSiPMArray = std::min(fFirstIdSiPMArray, i->GetId());
      }
      // The code inside asumes at least one: it initializes neighbors;
      // which don't exist if there's only one.
      if (fSiPMs.GetNumberOfComponents() > 1) {

        // To accumulate the ids to check'em.
        std::vector<int> check;
        // Preallocation.
        check.reserve(fSiPMs.GetNumberOfComponents());
        // Create a vector to Check Consecutiveness
        for (SiPMIterator i = fSiPMs.Begin(); i != fSiPMs.End(); ++i) {
          const int id        = i->GetId();
          check.push_back(id);

        } // End loop over SiPMs.
        //
        // Check Consecutiveness.
        //
        // It's likely that it will be already sorted
        // (DetectorComponent sorts while retreiving data)
        // but ensure that it's needed.
        //
        // It's known that there's one element at least.
        bool sorted = std::adjacent_find(check.begin(), check.end(),
          boost::lambda::_1 > boost::lambda::_2) == check.end();
        if (! sorted)
          std::sort(check.begin(), check.end());
        // Take the difference between all elements & overwrite the vector.
        std::adjacent_difference(check.begin(), check.end(), check.begin());
        // Remember that the first element is kept the same, so ignore it: that's why the + 1.
        // Now take the min & max: should be one if there's consecutiveness.
        typedef std::vector<int>::const_iterator It;
        std::pair< It, It > mm = boost::minmax_element(check.begin() + 1, check.end());
        if (*mm.first != 1 || *mm.second != 1) {
          std::ostringstream ss;
          ss << "There is no consecutiveness in the SiPMs of SiPMArray ";
          AddIdMessage(ss);
          ss << ".";
          FATAL(ss);
        }
      }
    }
  }



  void
  SiPMArray::Update(bool invalidateData, bool invalidateComponents)
  {
    MDetectorComponent<SiPMArray>::Type::Update(invalidateData, invalidateComponents);
    fSiPMs.Update(GetIdsMap(), invalidateData, invalidateComponents);
    // After update SiPMs, we may re-init them; if no component invalidation then
    // we skip this part which initializes fFirstIdSiPMArray (which won't change if no
    // component invalidation is performed).
    if (invalidateComponents)
      InitSiPMs();
  }

}