MDetector/Counter.h

Go to the documentation of this file.

#ifndef _mdet_Counter_h
#define _mdet_Counter_h

#include <det/VManager.h>
#include <det/MPositionable.h>
//
#include <mdet/MComponentGroup.h>
#include <mdet/MDetectorComponent.h>
#include <mdet/Module.h>
//
#include <utl/ShadowPtr.h>
#include <utl/CoordinateSystemPtr.h>

namespace sdet {
  class Station;
};

namespace mdet {

  class MDetector;
  class Counter : 
    public MDetectorComponent<Counter>::Type,
    public det::MPositionable<Counter>
  {
  private:
    typedef MComponentGroup<Counter, Module, det::ParentCreator>::Type 
      ModuleGroup;
  public:
    typedef ModuleGroup::ConstIterator ModuleConstIterator;
    /*
     * Name of the component, as of the needs of MDetectorComponent
     * template class.
     */
    static const char* const kComponentName;

    static const char* const kComponentId;
    ModuleConstIterator ModulesBegin() const {
      return GetModules().Begin();
    }
    ModuleConstIterator ModulesEnd() const {
      return GetModules().End();
    }
    const Module& GetModule(const int mId) const {
      return GetModules().Get(mId);
    }
    bool ExistsModule(const int mId) const {
      return GetModules().Exists(mId);
    }   
    int GetAssociatedTankId() const;
    const sdet::Station& GetAssociatedTank() const;
    
    //Segmentation getter
    unsigned int GetSegmentation() const { return fSegmentation; }

    //check if station is a dense station
    bool IsDense() const {return fDense;};

    // Get the counter area in square metres
    double GetArea() const;

   private:
    void Update(bool invalidateData, bool invalidateComponents);
    utl::CoordinateSystemPtr GetReferenceCoordinateSystem() const;
    Counter(int cId);
     ~Counter() { } 
    const ModuleGroup& GetModules() const {
      if (! fModulesUpdated) {
        if (fUseInvalidateFlags)
          fModules.Update(GetIdsMap(), fInvalidateData, fInvalidateComponents);
        else 
          fModules.Update(GetIdsMap());
        fModulesUpdated = true; // Modifies data.
      }
      return fModules;
    }
    friend class det::MPositionable<Counter>;
    friend struct det::IdOnlyCreator;
    template<class T>
    friend void boost::checked_delete(T*) BOOST_NOEXCEPT;
    friend struct det::ComponentUpdater;

    mutable utl::Validated<int> fAssociatedTankId;
    mutable bool fModulesUpdated;
    // Auxiliary flags to use in delayed updating (reflect the parameters of Update).
    bool fInvalidateData;
    bool fInvalidateComponents;
    // To indicate whether the "invalidate" flags are usable or need to be ignored.
    bool fUseInvalidateFlags;
    mutable ModuleGroup fModules;

    unsigned int fSegmentation;
    //Calculate segmentation of a given Counter
    void Segmentation() {
      fSegmentation = 0; 
      typedef ModuleConstIterator mIt;
      typedef mdet::Module::ScintillatorConstIterator sIt;
       for ( mIt mod = ModulesBegin(), mend = ModulesEnd(); mod!=mend; ++mod )
          for (sIt sci = mod->ScintillatorsBegin(), send = mod->ScintillatorsEnd(); sci != send; ++sci)
             ++fSegmentation;
    }

    bool fDense;

  };

}

#endif // _mdet_Counter_h