CbmMvdSensor.h

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                      CbmMvdSensor header file                -----
// -----                  Created 02/12/08  by M. Deveaux             -----
// -------------------------------------------------------------------------
 
 
#ifndef CBMMVDSENSOR_H
#define CBMMVDSENSOR_H 1
 
#include "CbmMvdDetectorId.h"
#include "TNamed.h"
 
#include "CbmMvdCluster.h"
#include "SensorDataSheets/CbmMvdSensorDataSheet.h"
#include "plugins/CbmMvdSensorPlugin.h"
 
#include "TClonesArray.h"
#include "TGeoBBox.h"
#include "TObjArray.h"
 
#include <map>
 
#include "TString.h"
 
// data classes
class CbmMvdPoint;
class CbmMvdDigi;
class TGeoHMatrix;
class TGeoHMatrix;
 
 
class CbmMvdSensor : public TNamed, CbmMvdDetectorId {
 
public:
  CbmMvdSensor();
 
 
  CbmMvdSensor(const char* name,
               CbmMvdSensorDataSheet* dataSheet,
               TString volName,
               TString nodeName,
               Int_t stationNr,
               Int_t volume,
               Double_t sensorStartTime);
 
 
  virtual ~CbmMvdSensor();
 
 
  Int_t GetStationNr() const { return fStationNr; }
  Int_t GetVolumeId() const { return fVolumeId; }
  Int_t GetDetectorID() const { return fDetectorID; };
  Int_t GetSensorNr() const { return fSensorNr; }
 
  Double_t GetDX() const { return fShape->GetDX(); };
  Double_t GetDY() const { return fShape->GetDY(); };
  Double_t GetDZ() const { return fShape->GetDZ(); };
  Double_t GetX() const {
    return fSensorPosition[0];
  };  // returns x position for pixle 0/0
  Double_t GetY() const {
    return fSensorPosition[1];
  };  // returns y position for pixle 0/0
  Double_t GetZ() const { return fSensorPosition[2]; };  // returns z position
  Double_t GetIntegrationtime() const {
    return fSensorData->GetIntegrationTime();
  };
  Double_t GetCurrentEventTime() const { return fcurrentEventTime; };
  Double_t GetReadoutTime(Double_t absoluteTime) const;
 
  TString GetNodeName() { return fNodeName; };
  CbmMvdSensorDataSheet* GetDataSheet() { return fSensorData; }
  void SetDataSheet(CbmMvdSensorDataSheet* sheet) { fSensorData = sheet; }
  void SetMap(std::map<Int_t, Int_t> SensorMap) {
    fSensorMap = SensorMap;
  }  // Get Sensor Map to identify every Sensor
  void SendInput(CbmMvdPoint* point);
  void SendInputDigi(CbmMvdDigi* digi);
  void SendInputDigiToHit(CbmMvdDigi* digi);
  void SendInputCluster(CbmMvdCluster* cluster);
  void SetStation(Int_t StationNumber) { fStationNr = StationNumber; }
 
 
  void LocalToTop(Double_t* local, Double_t* lab);
  void TopToLocal(Double_t* lab, Double_t* local);
  void LocalToPixel(Double_t* local, Int_t& pixelNumberX, Int_t& pixelNumberY);
  void PixelToLocal(Int_t pixelNumberX, Int_t pixelNumberY, Double_t* local);
  void PixelToTop(Int_t pixelNumberX, Int_t pixelNumberY, Double_t* lab);
  void TopToPixel(Double_t* lab, Int_t& pixelNumberX, Int_t& pixelNumberY);
  Int_t GetFrameNumber(Int_t pixelNumberY, Double_t absoluteTime) const;
  Int_t GetDigiPlugin() const { return fDigiPlugin; };
  Int_t GetHitPlugin() const { return fHitPlugin; };
  Int_t GetClusterPlugin() const { return fClusterPlugin; }
 
  void SetDigiPlugin(const Int_t& nPlugin) { fDigiPlugin = nPlugin; };
  void SetHitPlugin(const Int_t& nPlugin) { fHitPlugin = nPlugin; };
  void SetClusterPlugin(const Int_t& nPlugin) { fClusterPlugin = nPlugin; }
 
  void SetAlignment(TGeoHMatrix* alignmentMatrix);
  TGeoHMatrix* GetAlignmentCorr() { return fAlignmentCorr; };
  TGeoHMatrix* GetRecoMatrix() { return fRecoMatrix; };
 
 
  void ReadSensorGeometry(TString nodeName);
 
  void Init();
  void ShowDebugHistos();
  void SetPluginList(TObjArray* pluginArray) { fPluginArray = pluginArray; };
 
  void AddPlugin(CbmMvdSensorPlugin* plugin) {
    fPluginArray->AddLast((TObject*) plugin);
  };
 
  CbmMvdSensorPlugin* GetPlugin(UInt_t nPlugin) {
    return (CbmMvdSensorPlugin*) fPluginArray->At(nPlugin);
  }
 
  void SetMisalignment(Float_t misalignment[3]) {
    for (Int_t i = 0; i < 3; i++)
      epsilon[i] = misalignment[i];
  }
 
  virtual void Print(Option_t* opt = "") const;
 
  void ExecChain();           //runs chain of plugins
  void Exec(UInt_t nPlugin);  //runs individual plugin
  void ExecTo(UInt_t nPlugin);
  void ExecFrom(UInt_t nPlugin);
  void Finish();
 
  void ClearInputArray() { ; }
  //  void AddInputObject(TObject* dataObject);
 
  TClonesArray* GetOutputBuffer() const;
  TClonesArray* GetOutputArray(Int_t nPlugin) const;
  TClonesArray* GetOutputMatch() const;
  Int_t GetOutputArrayLen(Int_t nPlugin) const;
 
  void SetProduceNoise();
 
 
protected:
  Int_t fStationNr;   // Station identifier
  Int_t fSensorNr;    // Sensor identifier
  Int_t fVolumeId;    // MC unique volume ID
  Int_t fDetectorID;  // unique Detector ID
  Int_t fDigiPlugin;
  Int_t fHitPlugin;
  Int_t fDigiLen;
  Int_t fClusterPlugin;
  TString fVolName;   // Name of the volume attached to this sensor
  TString fNodeName;  // full name of the volume (including path) of the volume
  TClonesArray* foutputDigis;
  TClonesArray* foutputCluster;
  TClonesArray* foutputDigiMatch;
  TClonesArray* foutputBuffer;
  TClonesArray* fcurrentPoints;
  Double_t fcurrentEventTime;
  Float_t epsilon[3];
 
 
  TGeoBBox* fShape;  // volume corresponding to the sensor in the TGeoManager
  TGeoHMatrix*
    fMCMatrix;  // coordinate transformation from Master to MC-Position of this volume
  TGeoHMatrix* fRecoMatrix;  // The reconstructed position of the sensor
  TGeoHMatrix*
    fAlignmentCorr;  // Correction of the sensor position according to alignment
  Double_t
    fTempCoordinate[3];  // Just a vector to buffer temporarily position data.
  Double_t fSensorPosition[3];
 
  CbmMvdSensorDataSheet* fSensorData;
  std::map<Int_t, Int_t> fSensorMap;
 
  TObjArray* fPluginArray;
 
  Double_t fSensorStartTime;  // Defines the start time of the sensor
                              // as expressed according to CBM time stamps
                              // Unit: [s]
 
  Bool_t initialized;
 
private:
  CbmMvdSensor(const CbmMvdSensor&);
  CbmMvdSensor operator=(const CbmMvdSensor&);
 
  ClassDef(CbmMvdSensor, 1);
};
 
 
#endif