MDetector/Module.h

Go to the documentation of this file.

#ifndef _mdet_Module_h
#define _mdet_Module_h

#include <det/VManager.h>
#include <det/MPositionable.h>
//
#include <mdet/MComponentGroup.h>
#include <mdet/MDetectorComponent.h>
#include <mdet/Scintillator.h>
#include <mdet/Fiber.h>
#include <mdet/Pixel.h>
#include <mdet/PMT.h>
#include <mdet/FrontEnd.h>
#include <mdet/SiPM.h>
#include <mdet/SiPMArray.h>
#include <mdet/FrontEndSiPM.h>
#include <mdet/BackEndSiPM.h>
//
#include <utl/Point.h>
#include <utl/CoordinateSystemPtr.h>
#include <utl/ShadowPtr.h>
#include <utl/AugerException.h>
#include <utl/ConsecutiveEnumFactory.h>
#include <utl/Validated.h>
//
#include <sstream>
#include <string>
//
#include <boost/utility.hpp>

#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>


namespace mdet {

class Counter;


class Module : public MDetectorComponent<Module>::Type,
               public det::MPositionable<Module> {

private:
  typedef MComponentGroup<Module, Scintillator, det::ParentCreator>::Type ScintillatorGroup;

  typedef MComponentGroup<Module, Fiber, det::ParentCreator>::Type FiberGroup;

public:
  enum AreaKind {
    eSmall = 0,
    eLarge = 1,
  };

  enum PhotoDetector {
    ePMT = 0,
    eSiPM = 1,
  };

  static const char* const AreaKindTags[];

  typedef utl::ConsecutiveEnumFactory<AreaKind, eLarge, AreaKindTags> AreaKindCreator;

  static const char* const PhotoDetectorTags[];

  typedef utl::ConsecutiveEnumFactory<PhotoDetector, eSiPM, PhotoDetectorTags> PhotoDetectorCreator;

  static const char* const kComponentName;

  static const char* const kComponentId;


  typedef ScintillatorGroup::ConstIterator ScintillatorConstIterator;

  ScintillatorConstIterator ScintillatorsBegin() const { return fScintillators.Begin(); }

  ScintillatorConstIterator ScintillatorsEnd() const { return fScintillators.End(); }


  typedef FiberGroup::ConstIterator FiberConstIterator;

  FiberConstIterator FibersBegin() const { return fFibers.Begin(); }

  FiberConstIterator FibersEnd() const { return fFibers.End(); }


  template<class Component>
  const Fiber& GetFiberFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fFibers.Get(ids.fFiberId); }

  template<class Component>
  const Scintillator& GetScintillatorFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fScintillators.Get(ids.fScintillatorId); }

  template<class Component>
  const Pixel& GetPixelFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fPMT->GetPixels().Get(ids.fPixelId); }

  template<class Component>
  const SiPM& GetSiPMFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fSiPMArray->GetSiPMs().Get(ids.fPixelId); }

  template<class Component>
  const ChannelSiPM& GetChannelSiPMFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fFrontEndSiPM->GetChannels().Get(ids.fChannelId); }

  template<class Component>
  const Channel& GetChannelFor(const Component& c) const
  { const IdTuple ids = GetIdTuple(c); return fFrontEnd->GetChannels().Get(ids.fChannelId); }

  const Scintillator& GetScintillator(int sId) const { return fScintillators.Get(sId); }

  bool ExistsScintillator(const int sId) const { return fScintillators.Exists(sId); }

  const Channel& GetChannel(int cId) const { return fFrontEnd->GetChannels().Get(cId); }

  bool ExistsChannel(const int cId) const { return fFrontEnd->GetChannels().Exists(cId); }

  const ChannelSiPM& GetChannelSiPM(int cId) const { return fFrontEndSiPM->GetChannels().Get(cId); }

  bool ExistsChannelSiPM(const int cId) const { return fFrontEndSiPM->GetChannels().Exists(cId); }

  const Fiber& GetFiber(int fId) const { return fFibers.Get(fId); }

  bool ExistsFiber(const int fId) const { return fFibers.Exists(fId); }

  const Pixel& GetPixel(int pId) const { return fPMT->GetPixels().Get(pId); }

  bool ExistsPixel(const int pId) const { return fPMT->GetPixels().Exists(pId); }

  const SiPM& GetSiPM(const int pId) const { return fSiPMArray->GetSiPMs().Get(pId); }

  bool ExistsSiPM(const int pId) const { return fSiPMArray->GetSiPMs().Exists(pId); }

  int ScintillatorToChannelId(const int sId ) const
  { CheckComponent(); return fIndexByScintillator.find(sId)->fChannelId; }

  int ScintillatorToPixelId(const int sId) const
  { CheckComponent(); return fIndexByScintillator.find(sId)->fPixelId; }

  int ScintillatorToFiberId(const int sId) const
  { CheckComponent(); return fIndexByScintillator.find(sId)->fFiberId; }

  int ChannelToScintillatorId(const int cId) const
  { CheckComponent(); return fIndexByChannel.find(cId)->fScintillatorId; }

  int ChannelToPixelId(const int cId) const
  { CheckComponent(); return fIndexByChannel.find(cId)->fPixelId; }

  int ChannelToFiberId(const int cId) const
  { CheckComponent(); return fIndexByChannel.find(cId)->fFiberId; }

  int FiberToChannelId(const int fId) const
  { CheckComponent(); return fIndexByFiber.find(fId)->fChannelId; }

  int FiberToScintillatorId(const int fId) const
  { CheckComponent(); return fIndexByFiber.find(fId)->fScintillatorId; }

  int FiberToPixelId(const int fId) const
  { CheckComponent(); return fIndexByFiber.find(fId)->fPixelId; }

  int PixelToScintillatorId(const int pId) const
  { CheckComponent(); return fIndexByPixel.find(pId)->fScintillatorId; }

  int PixelToFiberId(const int pId) const
  { CheckComponent(); return fIndexByPixel.find(pId)->fFiberId; }

  int PixelToChannelId(const int pId) const
  { CheckComponent(); return fIndexByPixel.find(pId)->fChannelId; }

  // The area of the module in square meters
  double GetArea() const;

  // Number of scintillators in the module
  unsigned int GetNumberOfScintillators() const;

  double GetDepth() const;

  // The depth of the given point.
  double GetDepth(const utl::Point& p) const;

  // The front-end mask of broken channels.
  ULong64_t GetMask() const;

  const Counter& GetCounter() const;

  // Retrieves the PMT that belongs to the module.
  const PMT& GetPMT() const;

  // Retrieves the SiPMArray that belongs to the module.
  const SiPMArray& GetSiPMArray() const;

  // Retrieves the electronic FrontEnd that belong to the module.
  const FrontEnd& GetFrontEnd() const;

  // Retrieves the electronic FrontEnd that belong to the module.
  const FrontEndSiPM& GetFrontEndSiPM() const;

  // Retrieves the electronic FrontEnd that belong to the module.
  const BackEndSiPM& GetBackEndSiPM() const;

  // The specific kind of Module.
  AreaKind GetAreaKind() const;

  // The photoDetector of Module.
  PhotoDetector GetPhotoDetector() const;

  double GetBackgroundMuonsFlux() const;
  
  double GetPhi0() const;

  bool IsSiPM() const; //returns true for a module with SiPM array

  double GetShortestFiber() const;

private:
  // Perform update in this component and forward to subcomponents.
  void Update(const bool invalidateData, const bool invalidateComponents);

  utl::CoordinateSystemPtr GetReferenceCoordinateSystem() const;

  Module(const int mId, const det::VManager::IndexMap& parentMap, const Counter& parent);

  ~Module() { }

  // Frienship for GetData callback.
  friend class det::MPositionable<Module>;

  template<class T>
  friend void boost::checked_delete(T*) BOOST_NOEXCEPT;

  // Friendship to allow creation (or call it construction).
  friend struct det::ParentCreator;

  friend struct det::ComponentUpdater;

  ScintillatorGroup fScintillators;

  FiberGroup fFibers;

  utl::ShadowPtr<PMT> fPMT;

  utl::ShadowPtr<SiPMArray> fSiPMArray;

  utl::ShadowPtr<FrontEnd> fFrontEnd;

  utl::ShadowPtr<FrontEndSiPM> fFrontEndSiPM;

  utl::ShadowPtr<BackEndSiPM> fBackEndSiPM;

  const Counter& fCounter;

  // Alias for a type considered within the config hierarchy, to be converted to the actual enum
  typedef std::string AreaKindForConfig;

  mutable utl::Validated<AreaKindForConfig> fAreaKind;

  // Alias for a type considered within the config hierarchy, to be converted to the actual enum
  typedef std::string PhotoDetectorForConfig;

  mutable utl::Validated<PhotoDetectorForConfig> fPhotoDetector;

  mutable utl::Validated<double> fBackgroundMuonsFlux;

  struct IdTuple {
    int fChannelId;
    int fPixelId;
    int fScintillatorId;
    int fFiberId;
  };

  //dummies needed to access the different indices of the IndexContainer
  struct ChannelTag {
  };

  struct PixelTag {
  };

  struct ScintillatorTag {
  };

  struct FiberTag {
  };

  // container for the mapping between different indices (Pixel/Scintillator/Channel/Fiber)

  typedef boost::multi_index_container<
    IdTuple,
    boost::multi_index::indexed_by<
      boost::multi_index::ordered_unique<
        boost::multi_index::tag<ChannelTag>, boost::multi_index::member< IdTuple, int, &IdTuple::fChannelId >
      >,
      boost::multi_index::ordered_unique<
        boost::multi_index::tag<PixelTag>, boost::multi_index::member< IdTuple, int, &IdTuple::fPixelId >
      >,
      boost::multi_index::ordered_unique<
        boost::multi_index::tag<ScintillatorTag>, boost::multi_index::member< IdTuple, int, &IdTuple::fScintillatorId >
      >,
      boost::multi_index::ordered_unique<
        boost::multi_index::tag<FiberTag>, boost::multi_index::member< IdTuple, int, &IdTuple::fFiberId >
      >  //close ordered_unique
    >  //close indexed_by
  > IndexContainer; //close typedef

  typedef IndexContainer::index<ChannelTag>::type IndexByChannelId;
  typedef IndexContainer::index<PixelTag>::type IndexByPixelId;
  typedef IndexContainer::index<ScintillatorTag>::type IndexByScintillatorId;
  typedef IndexContainer::index<FiberTag>::type IndexByFiberId;

  IndexContainer fIndexRelations;
  IndexByChannelId& fIndexByChannel;
  IndexByPixelId& fIndexByPixel;
  IndexByScintillatorId& fIndexByScintillator;
  IndexByFiberId& fIndexByFiber;

  /*
    VERY VERY DIRTY SOLUTION TO IMPLEMENT LAZY INITIALIZATION IN THE IDS OF
    CHANNELS/SCINTILLATORS AND FIBERS
    (but in any case implies an improvement of 40 times faster runs!)
  */
  void
  CheckComponent()
    const
  {
#if 1
         if (fIndexByChannel.empty()) {
                 if(!IsSiPM()){
                         for (mdet::PMT::PixelConstIterator pixIt = fPMT->PixelsBegin(); pixIt != fPMT->PixelsEnd(); ++pixIt) {
                                 const Pixel& pix = *pixIt;
                                 const IdsContainer ids = pix.GetChannelScintillatorFiberIds();
                                 if (ids.size() != 3) {
                                         FATAL("The information in MModelConfig is corrupt! Number of indeces in "
                                                         "<channelScintillatorFiberIds> has to be three");
                                 }
                                 IdTuple newtuple;
                                 newtuple.fScintillatorId = ids[1];
                                 newtuple.fFiberId = ids[2];
                                 newtuple.fPixelId = pixIt->GetId();
                                 newtuple.fChannelId = ids[0];
                                 fIndexByChannel.insert(newtuple);
                         }
                 }else{
                         for (mdet::SiPMArray::SiPMConstIterator sipmIt = fSiPMArray->SiPMsBegin(); sipmIt != fSiPMArray->SiPMsEnd(); ++sipmIt) {
                                 const SiPM& sipm = *sipmIt;
                                 const IdsContainer ids = sipm.GetChannelSiPMScintillatorFiberIds();
                                 if (ids.size() != 3) {
                                         FATAL("The information in MModelConfig is corrupt! Number of indeces in "
                                                         "<channelScintillatorFiberIds> has to be three");
                                 }
                                 IdTuple newtuple;
                                 newtuple.fScintillatorId = ids[1];
                                 newtuple.fFiberId = ids[2];
                                 newtuple.fPixelId = sipmIt->GetId();
                                 newtuple.fChannelId = ids[0];
                                 fIndexByChannel.insert(newtuple);
                         }
                 }
         }
#endif
  }

  IdTuple GetIdTuple(const Channel& c) const
  { CheckComponent(); return *fIndexByChannel.find(c.GetId()); }

  IdTuple GetIdTuple(const Pixel& p) const
  { CheckComponent(); return *fIndexByPixel.find(p.GetId()); }

  IdTuple GetIdTuple(const ChannelSiPM& c) const
  { CheckComponent(); return *fIndexByChannel.find(c.GetId()); }

  IdTuple GetIdTuple(const SiPM& p) const
  { CheckComponent(); return *fIndexByPixel.find(p.GetId()); }

  IdTuple GetIdTuple(const Scintillator& s) const
  { CheckComponent(); return *fIndexByScintillator.find(s.GetId()); }

  IdTuple GetIdTuple(const Fiber& f) const
  { CheckComponent(); return *fIndexByFiber.find(f.GetId()); }

};

}


#endif