DetectorInterna.h

Go to the documentation of this file.

//==========================================================================
//  AIDA Detector description implementation for LCD
//--------------------------------------------------------------------------
// 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
//
//==========================================================================
//
// NOTE:
//
// This is an internal include file. It should only be included to 
// instantiate code. Otherwise the Detector include file should be
// sufficient for all practical purposes.
//
//==========================================================================
#ifndef DD4HEP_GEOMETRY_DETECTORINTERNA_H
#define DD4HEP_GEOMETRY_DETECTORINTERNA_H

// Framework include files
#include "DD4hep/Callback.h"
#include "DD4hep/NamedObject.h"
#include "DD4hep/World.h"
#include "DD4hep/Objects.h"
#include "DD4hep/Detector.h"
#include "DD4hep/Alignments.h"
#include "DD4hep/Conditions.h"
#include "DD4hep/Segmentations.h"
#include "DD4hep/ObjectExtensions.h"

// ROOT include files
#include "TGeoMatrix.h"

namespace DD4hep {

  namespace Geometry {

    class LCDD;
    class WorldObject;
    class DetElementObject;
    class SensitiveDetectorObject;


    class SensitiveDetectorObject: public NamedObject, public ObjectExtensions {
    public:
      unsigned int magic;
      int          verbose;
      int          combineHits;
      double       ecut;
      Readout      readout;
      Region       region;
      LimitSet     limits;
      std::string  hitsCollection;

      SensitiveDetectorObject();
      SensitiveDetectorObject(const std::string& nam);
      virtual ~SensitiveDetectorObject();
    };


    class DetElementObject: public NamedObject, public ObjectExtensions {
    public:
      // Type definitions.
      // The full namespace declaration is required by cint....
      typedef /* DD4hep::Geometry:: */  DetElement::destruct_t destruct_t;
      typedef /* DD4hep::Geometry:: */  DetElement::copy_t     copy_t;

      typedef /* DD4hep::Geometry:: */  DetElement::Children   Children;
      typedef /* DD4hep::Geometry:: */  DetElement::Extensions Extensions;
      typedef std::pair<Callback,unsigned long>    UpdateCall;
      typedef std::vector<UpdateCall>              UpdateCallbacks;
      typedef Conditions::Container                ConditionsContainer;
      typedef Conditions::Condition                Condition;
      typedef Alignments::Alignment                Alignment;
      typedef Alignments::Container                AlignmentsContainer;

      enum DetFlags {
        HAVE_WORLD_TRAFO        = 1<<0,
        HAVE_PARENT_TRAFO       = 1<<1,
        HAVE_REFERENCE_TRAFO    = 1<<2,
        HAVE_SENSITIVE_DETECTOR = 1<<29,
        IS_TOP_LEVEL_DETECTOR   = 1<<30,
        HAVE_OTHER              = 1<<31
      };

      unsigned int        magic;
      unsigned int        flag;
      int                 id;
      int                 combineHits;
      unsigned int        typeFlag;
      int                 level;
      unsigned int        key;
      std::string         path;
      std::string         placementPath;

      PlacedVolume        idealPlace;
      PlacedVolume        placement;

      VolumeID            volumeID;
      World               privateWorld;
      DetElement          parent;
      DetElement          reference;
      Children            children;
      UpdateCallbacks     updateCalls;

      Alignment           nominal;
      Alignment           survey;
      AlignmentsContainer alignments;
      ConditionsContainer conditions;

      Ref_t               global_alignment;

      // To be removed!
      std::vector<Alignment> volume_alignments;
      std::vector<Alignment> volume_surveys;

      TGeoHMatrix worldTrafo;
      TGeoHMatrix parentTrafo;
      TGeoHMatrix* referenceTrafo;

    private:
      World i_access_world();

    public:
      DetElementObject(const std::string& nam, int ident);
      DetElementObject();
      virtual ~DetElementObject();
      virtual DetElementObject* clone(int new_id, int flag) const;
      World world()
      {  return privateWorld.isValid() ? privateWorld : i_access_world(); }
      ConditionsContainer assign_conditions();
      const TGeoHMatrix& worldTransformation();
      const TGeoHMatrix& parentTransformation();
      const TGeoHMatrix& referenceTransformation();
      void removeAtUpdate(unsigned int type, void* pointer);
      void update(unsigned int tags, void* param);
      void revalidate(TGeoHMatrix* parent_world_trafo);
    };


    class WorldObject: public DetElementObject {
    public:
      typedef Conditions::ConditionsLoader        ConditionsLoader;
      typedef Conditions::ConditionsManagerObject ConditionsManagerObject;
      typedef Alignments::AlignmentsLoader        AlignmentsLoader;
      typedef Alignments::AlignmentsManagerObject AlignmentsManagerObject;

      LCDD* lcdd;

      ConditionsLoader*        conditionsLoader;

      ConditionsManagerObject* conditionsManager;

      AlignmentsLoader*        alignmentsLoader;

      AlignmentsManagerObject* alignmentsManager;

    public:
      WorldObject();
#ifndef __CINT__
      WorldObject(LCDD& lcdd, const std::string& nam);
#endif
      virtual ~WorldObject();
   };

    inline WorldObject::WorldObject()
      : DetElementObject(), lcdd(0), 
      conditionsLoader(0), conditionsManager(0), alignmentsLoader(0), alignmentsManager(0)
      {
      }

  } /* End namespace Geometry      */
} /* End namespace DD4hep        */
#endif    /* DD4HEP_GEOMETRY_DETECTORINTERNA_H      */