CSCGeometry.h

Go to the documentation of this file.

#ifndef CSCGeometry_CSCGeometry_h
#define CSCGeometry_CSCGeometry_h

#include <DataFormats/DetId/interface/DetId.h>
#include <DataFormats/MuonDetId/interface/CSCDetId.h>
#include <Geometry/CommonDetUnit/interface/TrackingGeometry.h>
#include <Geometry/CSCGeometry/interface/CSCLayer.h>
#include <vector>
#include <map>

class GeomDetType;
class GeomDetUnit;
class CSCChamber;
class CSCChamberSpecs;
class CSCWireGroupPackage;

class CSCGeometry : public TrackingGeometry {

  typedef std::map<DetId, GeomDet*> CSCDetMap;
  // The buffer for specs need not really be a map. Could do it with a vector!
  typedef std::map<int, const CSCChamberSpecs*, std::less<int> > CSCSpecsContainer;
  typedef std::vector<CSCChamber*> ChamberContainer;
  typedef std::vector<CSCLayer*> LayerContainer;

 public:

  friend class CSCGeometryBuilder; //FromDDD;
  friend class GeometryAligner;

  CSCGeometry();

  virtual ~CSCGeometry();

  //---- Base class' interface

  // Return a vector of all det types
  virtual const DetTypeContainer&  detTypes() const;

  // Return a vector of all GeomDetUnit
  virtual const DetUnitContainer& detUnits() const;

  // Return a vector of all GeomDet (including all GeomDetUnits)
  virtual const DetContainer& dets() const;
  
  // Return a vector of all GeomDetUnit DetIds
  virtual const DetIdContainer&    detUnitIds() const;

  // Return a vector of all GeomDet DetIds (including those of GeomDetUnits)
  virtual const DetIdContainer& detIds() const;

  // Return the pointer to the GeomDetUnit corresponding to a given DetId
  virtual const GeomDetUnit* idToDetUnit(DetId) const;

  // Return the pointer to the GeomDet corresponding to a given DetId
  virtual const GeomDet* idToDet(DetId) const;

  //---- Extension of the interface

  const CSCChamber* chamber(CSCDetId id) const;

  const CSCLayer* layer(CSCDetId id) const;

  const ChamberContainer& chambers() const;

  const LayerContainer& layers() const;



  const CSCChamberSpecs* findSpecs( int iChamberType );

  const CSCChamberSpecs* buildSpecs( int iChamberType,
                 const std::vector<float>& fpar,
                 const std::vector<float>& fupar,
                 const CSCWireGroupPackage& wg );

  void setGangedStripsInME1a(bool gs) { gangedstripsME1a = gs; }
  void setOnlyWiresInME1a(bool ow) { onlywiresME1a = ow; }
  void setUseRealWireGeometry(bool wg) { useRealWireGeometry = wg; }
  void setUseCentreTIOffsets(bool cti) { useCentreTIOffsets = cti; }
  void setDebugV(bool dbgv) { debugV = dbgv; }

  bool gangedStrips() const { return gangedstripsME1a; }

  bool wiresOnly() const { return onlywiresME1a; }

  bool realWireGeometry() const { return useRealWireGeometry; }

  bool centreTIOffsets() const { return useCentreTIOffsets; }

  void queryModelling() const;

 private:

  void addChamber(CSCChamber* ch);
  
  void addLayer(CSCLayer* l);

  void addDetType(GeomDetType* type);

  void addDetId(DetId id);

  void addDet(GeomDet* det);

  // The chambers are owned by the geometry (which in turn own layers)
  ChamberContainer  theChambers; 

  // Map for efficient lookup by DetId 
  CSCDetMap         theMap;

  // These are used rarely; they could be computed at runtime 
  // to save memory.
  DetTypeContainer  theDetTypes;
  DetContainer      theDets;       // all dets (chambers and layers)
  DetUnitContainer  theDetUnits;   // all layers
  DetIdContainer    theDetIds;
  DetIdContainer    theDetUnitIds;

  // These are reduntant copies, to satisfy the interface.
  LayerContainer    theLayers;

  // Parameters controlling modelling of geometry 

  bool debugV; // for debug printout etc.

  bool gangedstripsME1a;
  bool onlywiresME1a;
  bool useRealWireGeometry;
  bool useCentreTIOffsets;

  // Store pointers to Specs objects as we build them.
  CSCSpecsContainer specsContainer;

};

#endif