CbmMvdSensor.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                     CbmMvdSensor source file                  -----
// -----                  Created 31/01/11  by M. Deveaux              -----
// -------------------------------------------------------------------------
 
#include "CbmMvdSensor.h"
 
//---Plugins
#include "plugins/buffers/CbmMvdSensorFrameBuffer.h"
#include "plugins/buffers/CbmMvdSensorTrackingBuffer.h"
#include "plugins/tasks/CbmMvdSensorClusterfinderTask.h"  //not needed khun
#include "plugins/tasks/CbmMvdSensorDigiToHitTask.h"
#include "plugins/tasks/CbmMvdSensorDigitizerTBTask.h"
#include "plugins/tasks/CbmMvdSensorDigitizerTask.h"
#include "plugins/tasks/CbmMvdSensorFindHitTask.h"
#include "plugins/tasks/CbmMvdSensorHitfinderTask.h"  //not needed khun
//---Plugins
 
#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include "TGeoVolume.h"
 
#include "FairEventHeader.h"
#include "FairLogger.h"
#include "FairMCEventHeader.h"
#include "FairPrimaryGenerator.h"
#include "FairRunAna.h"
#include "FairRunSim.h"
 
#include <iostream>
#include <vector>
 
using std::cout;
using std::endl;
using std::map;
using std::vector;
 
// -----   Default constructor   -------------------------------------------
CbmMvdSensor::CbmMvdSensor()
  : TNamed()
  , fStationNr(0)
  , fSensorNr(0)
  , fVolumeId(-1)
  , fDetectorID(-1)
  , fDigiPlugin(-1)
  , fHitPlugin(-1)
  , fDigiLen(-1)
  , fClusterPlugin(-1)
  , fVolName("")
  , fNodeName("")
  , foutputDigis(NULL)
  , foutputCluster(NULL)
  ,  //not needed khun
  foutputDigiMatch(NULL)
  , foutputBuffer(NULL)
  , fcurrentPoints(NULL)
  , fcurrentEventTime(0.)
  , epsilon()
  , fShape(NULL)
  , fMCMatrix(NULL)
  , fRecoMatrix(NULL)
  , fAlignmentCorr(NULL)
  , fTempCoordinate()
  , fSensorPosition()
  , fSensorData(new CbmMvdSensorDataSheet())
  , fSensorMap()
  , fPluginArray(new TObjArray(1))
  , fSensorStartTime(0.)
  , initialized(kFALSE) {
  cout << "-W- " << GetName()
       << ": MVD-Sensor initialized without technical data.";
  cout << " Assuming default sensor." << endl;
 
  cout << "-W- " << GetName()
       << ": MVD-Sensor initialized without geometry data. ";
  cout << " Must be added manually before using this class." << endl;
 
  cout << "-W- " << GetName()
       << ": MVD-Sensor initialized without valid start time. ";
  cout << " Must be added manually before using this class." << endl;
}
// -------------------------------------------------------------------------
 
 
// -----   Standard constructor   ------------------------------------------
CbmMvdSensor::CbmMvdSensor(const char* name,
                           CbmMvdSensorDataSheet* dataSheet,
                           TString volName,
                           TString nodeName,
                           Int_t stationNr,
                           Int_t volumeId,
                           Double_t sensorStartTime)
  : TNamed(name, "")
  , fStationNr()
  , fSensorNr(stationNr)
  , fVolumeId(volumeId)
  , fDetectorID(DetectorId(stationNr))
  , fDigiPlugin(-1)
  , fHitPlugin(-1)
  , fDigiLen(-1)
  , fClusterPlugin(-1)
  , fVolName(volName)
  , fNodeName(nodeName)
  , foutputDigis(NULL)
  , foutputCluster(NULL)
  ,  //not needed khun
  foutputDigiMatch(NULL)
  , foutputBuffer(NULL)
  , fcurrentPoints(NULL)
  , fcurrentEventTime(0.)
  , epsilon()
  , fShape(NULL)
  , fMCMatrix(NULL)
  , fRecoMatrix(NULL)
  , fAlignmentCorr(NULL)
  , fTempCoordinate()
  , fSensorPosition()
  , fSensorData(dataSheet)
  , fSensorMap()
  , fPluginArray(new TObjArray(1))
  , fSensorStartTime(sensorStartTime)
  , initialized(kFALSE) {}
// -------------------------------------------------------------------------
 
 
// -----   Destructor   ----------------------------------------------------
CbmMvdSensor::~CbmMvdSensor() { delete fSensorData; }
// -------Setters -----------------------------------------------------
 
void CbmMvdSensor::SetAlignment(TGeoHMatrix* alignmentMatrix) {
 
  if (fAlignmentCorr) { delete fAlignmentCorr; };
  fAlignmentCorr =
    (TGeoHMatrix*) alignmentMatrix->Clone(fNodeName + "_AlignmentData");
}
 
 
// -------Initialization tools  -----------------------------------------------------
void CbmMvdSensor::ReadSensorGeometry(TString nodeName) {
 
  LOG(debug1) << "-I- nodeName is " << nodeName;
 
  if (fMCMatrix) {
    delete fMCMatrix;
  };  //delete local copy of the position information
 
  TGeoVolume* volume;
  gGeoManager->cd(nodeName);
  volume = gGeoManager->GetCurrentVolume();
  LOG(debug2) << "At volume: " << volume->GetName();
  fShape    = (TGeoBBox*) volume->GetShape();
  fMCMatrix = (TGeoHMatrix*) (gGeoManager->GetCurrentMatrix())
                ->Clone(nodeName + "_MC_Matrix");
  fMCMatrix->SetName(nodeName + "_MC_Matrix");
 
  Double_t first[3], last[3];
  PixelToLocal(0, 0, first);
  PixelToLocal(fSensorData->GetNPixelsX(), fSensorData->GetNPixelsY(), last);
  LOG(debug2) << "pixel 0,0 at: " << first[0] << ", " << first[1] << " Local";
  LOG(debug2) << "pixel " << fSensorData->GetNPixelsX() << " "
              << fSensorData->GetNPixelsY() << " at: " << last[0] << ", "
              << last[1] << " Local";
 
  Double_t* tempCoordinate;
 
  if (!fRecoMatrix) {
    Double_t pre[3], past[3], global[3];
    Double_t local[3] = {0, 0, 0};
    //The initial guess on the reconstructed position is that the MC-position is correct
    //Short cut to misalignment, add a small error
    fRecoMatrix = (TGeoHMatrix*) fMCMatrix->Clone(nodeName + "_Reco_Matrix");
    PixelToTop(0, 0, pre);
    tempCoordinate = fRecoMatrix->GetTranslation();
    for (Int_t i = 0; i < 3; i++) {
      tempCoordinate[i] = tempCoordinate[i] + epsilon[i];
    }
    fRecoMatrix->SetTranslation(tempCoordinate);
    PixelToTop(0, 0, past);
    LOG(debug2) << "shifted pixel 0,0 to: " << past[0] << ", " << past[1]
                << " at z = " << past[2];
    LocalToTop(local, global);
    LOG(debug2) << "shifted local center to: " << global[0] << ", " << global[1]
                << " at z = " << global[2];
  } else {
    tempCoordinate = fRecoMatrix->GetTranslation();
  }
  if (!fAlignmentCorr) {
    //If no knowledge on the reco matrix is available there is plausibly no correction data.
    fAlignmentCorr = new TGeoHMatrix(nodeName + "_AlignmentData");
  }
 
  for (Int_t i = 0; i < 3; i++) {
    fSensorPosition[i] = tempCoordinate[i];
  }
}
 
//-------------------------------------------------------------------
 
//-------------------------------------------------------------------
void CbmMvdSensor::Init() {
 
  ReadSensorGeometry(fNodeName);
 
 
  if (!initialized) {
    foutputDigis     = new TClonesArray("CbmMvdDigi", 1000);
    foutputDigiMatch = new TClonesArray("CbmMatch", 1000);
    foutputBuffer    = new TClonesArray("CbmMvdHit", 1000);
    foutputCluster   = new TClonesArray("CbmMvdCluster", 1);  //not needed khun
  }
 
  Int_t nPlugin = fPluginArray->GetEntriesFast();
 
 
  TClonesArray* dataArray;
 
  CbmMvdSensorTask* gentask;
  CbmMvdSensorBuffer* genBuffer;
 
  CbmMvdSensorPlugin *pluginFirst, *pluginNext;
 
  for (Int_t i = 0; i < nPlugin; i++) {
    pluginFirst = (CbmMvdSensorPlugin*) fPluginArray->At(i);
    if (pluginFirst->GetPluginType() == buffer) {
      genBuffer = (CbmMvdSensorBuffer*) fPluginArray->At(i);
      genBuffer->InitBuffer(this);
    }
    if (pluginFirst->GetPluginType() == task) {
      gentask = (CbmMvdSensorTask*) fPluginArray->At(i);
      gentask->InitTask(this);
    }
  }
  //Link data chain
  if (nPlugin > 1) {
 
    for (Int_t i = 0; i < nPlugin - 1; i++) {
 
      pluginFirst = (CbmMvdSensorPlugin*) fPluginArray->At(i);
      pluginNext  = (CbmMvdSensorPlugin*) fPluginArray->At(i + 1);
 
      //Rules: The output array of the previous plugin is input of the next
      dataArray = pluginFirst->GetOutputArray();
      pluginNext->SetInputArray(dataArray);
 
      //The plugin knows its precessor and sucessor to communicate
      pluginFirst->SetNextPlugin(pluginNext);
      pluginNext->SetPreviousPlugin(pluginFirst);
    }
  }
 
 
  if (nPlugin == 0) {
    LOG(debug) << "No Plugins on this Sensor ";
    pluginFirst = NULL;
  }
  initialized = kTRUE;
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
void CbmMvdSensor::ShowDebugHistos() {
  //if(fDetectorID == 1537)
  {
    CbmMvdSensorPlugin* pluginLast;
    pluginLast = (CbmMvdSensorPlugin*) fPluginArray->At(
      fPluginArray->GetEntriesFast() - 1);
    cout << endl
         << "Set debug mode on Plugin " << fPluginArray->GetEntriesFast() - 1
         << " at sensor " << GetName() << endl;
    pluginLast->ShowDebugHistos();
  }
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
void CbmMvdSensor::SetProduceNoise() {
  CbmMvdSensorPlugin* pluginFirst;
  // CbmMvdSensorFrameBuffer* framebuffer;
  CbmMvdSensorDigitizerTask* digitask;
 
  pluginFirst = (CbmMvdSensorPlugin*) fPluginArray->At(0);
  if (pluginFirst->GetPluginType() == buffer) {
    return;
  } else if (pluginFirst->GetPluginType() == task) {
    TString digitizername = "CbmMvdSensorDigitizerTask";
 
    if (pluginFirst->ClassName() == digitizername) {
      digitask = (CbmMvdSensorDigitizerTask*) fPluginArray->At(0);
      digitask->SetProduceNoise();
    }
 
    else {
      LOG(fatal) << "Invalid input typ";
    }
 
  } else {
    cout << endl << "ERROR!! undefind plugin!" << endl;
  }
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
void CbmMvdSensor::SendInput(CbmMvdPoint* point) {
 
  CbmMvdSensorPlugin* pluginFirst;
 
  CbmMvdSensorTask* digitask;
 
  pluginFirst = (CbmMvdSensorPlugin*) fPluginArray->At(0);
 
  if (pluginFirst->GetPluginType() == task) {
    TString digitizername   = "CbmMvdSensorDigitizerTask";
    TString digitizerTBname = "CbmMvdSensorDigitizerTBTask";
 
    if (pluginFirst->ClassName() == digitizername
        || pluginFirst->ClassName() == digitizerTBname) {
      digitask = (CbmMvdSensorTask*) fPluginArray->At(0);
      digitask->SetInput(point);
    }
 
    else {
      LOG(fatal) << "Invalid input typ";
    }
 
  } else {
    cout << endl << "ERROR!! undefind plugin!" << endl;
  }
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::SendInputDigi(CbmMvdDigi* digi)  //for old CF
{
  if (fHitPlugin != -1) {
    CbmMvdSensorClusterfinderTask* clustertask =
      (CbmMvdSensorClusterfinderTask*) fPluginArray->At(fClusterPlugin);
    clustertask->SetInputDigi(digi);
  } else {
    cout << endl << "Somthing seems fishy here" << endl;
  }
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::SendInputDigiToHit(CbmMvdDigi* digi)  //for DigiToHit
{
  if (fHitPlugin != -1) {
    CbmMvdSensorDigiToHitTask* digitohittask =
      (CbmMvdSensorDigiToHitTask*) fPluginArray->At(fHitPlugin);
    digitohittask->SetInputDigi(digi);
  } else {
    cout << endl << "Somthing seems fishy here" << endl;
  }
}
// -------------------------------------------------------------------------
 
 
//not needed khun/*
// -------------------------------------------------------------------------
void CbmMvdSensor::SendInputCluster(CbmMvdCluster* cluster) {
  if (fHitPlugin != -1) {
    CbmMvdSensorHitfinderTask* findertask =
      (CbmMvdSensorHitfinderTask*) fPluginArray->At(fHitPlugin);
    findertask->SetInputCluster(cluster);
  } else {
    cout << endl << "Somthing seems fishy in SendInputCluster" << endl;
  }
}
// -------------------------------------------------------------------------
//not needed khun */
 
 
// -------------------------------------------------------------------------
 
void CbmMvdSensor::ExecChain() {
 
  FairRunSim* run = FairRunSim::Instance();
  FairRunAna* ana = FairRunAna::Instance();
  if (run) {
    FairEventHeader* event = run->GetEventHeader();
    fcurrentEventTime      = event->GetEventTime();
  }
  if (ana) {
    FairEventHeader* event = ana->GetEventHeader();
    fcurrentEventTime      = event->GetEventTime();
  }
  foutputDigis->Clear("C");
  foutputDigiMatch->Clear("C");
  foutputCluster->Clear("C");  //not needed khun
  foutputBuffer->Clear("C");
 
 
  CbmMvdSensorPlugin* plugin;
  Int_t nPlugin = fPluginArray->GetEntriesFast();
 
  plugin = (CbmMvdSensorPlugin*) fPluginArray->At(0);
 
  plugin->ExecChain();
  //cout << endl << "is plugin ready? "<< plugin->PluginReady() << " on sensor "<< this->GetName()  << endl;
  if (plugin->PluginReady()) {
    //cout << endl << "exec chain on sensor "<< this->GetName() << endl;
    for (Int_t i = 1; i < nPlugin; i++) {
      //cout << endl << "exec plugin " << i << " on sensor "<< this->GetName() << endl;
      plugin = (CbmMvdSensorPlugin*) fPluginArray->At(i);
      plugin->ExecChain();
    }
  }
}
// -------------------------------------------------------------------------
 
void CbmMvdSensor::Exec(UInt_t nPlugin) {
  foutputDigis->Clear("C");
  foutputDigiMatch->Clear("C");
  foutputCluster->Clear("C");  //not needed khun
  foutputBuffer->Clear("C");
  UInt_t nPluginMax = fPluginArray->GetEntriesFast();
  if (nPlugin > nPluginMax) {
    Fatal(GetName(), " Error - Called non-existing plugin");
  }
  CbmMvdSensorPlugin* plugin = (CbmMvdSensorPlugin*) fPluginArray->At(nPlugin);
  plugin->Exec();
}
// -------------------------------------------------------------------------
void CbmMvdSensor::ExecTo(UInt_t nPlugin) {
  FairRunSim* run           = FairRunSim::Instance();
  FairPrimaryGenerator* gen = run->GetPrimaryGenerator();
  FairMCEventHeader* event  = gen->GetEvent();
 
  foutputDigis->Delete();
  foutputCluster->Delete();  //not needed khun
  foutputDigiMatch->Clear("C");
  foutputBuffer->Clear("C");
 
  fcurrentEventTime = event->GetT();
 
  CbmMvdSensorPlugin* plugin;
  UInt_t maxPlugin = fPluginArray->GetEntriesFast();
 
  plugin = (CbmMvdSensorPlugin*) fPluginArray->At(0);
  if (nPlugin < maxPlugin) {
    plugin->ExecChain();
    //cout << endl << "is plugin ready? "<< plugin->PluginReady() << " on sensor "<< this->GetName()  << endl;
    if (plugin->PluginReady()) {
      //cout << endl << "exec chain on sensor "<< this->GetName() << endl;
      for (UInt_t i = 1; i <= nPlugin; i++) {
        //cout << endl << "exec plugin " << i << " on sensor "<< this->GetName() << endl;
        plugin = (CbmMvdSensorPlugin*) fPluginArray->At(i);
        plugin->ExecChain();
      }
    }
  } else {
    cout << endl << "nPlugin to large" << endl;
  }
}
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::ExecFrom(UInt_t nPlugin) {
  FairRunSim* run           = FairRunSim::Instance();
  FairPrimaryGenerator* gen = run->GetPrimaryGenerator();
  FairMCEventHeader* event  = gen->GetEvent();
 
  fcurrentEventTime = event->GetT();
 
  CbmMvdSensorPlugin* plugin;
  UInt_t maxPlugin = fPluginArray->GetEntriesFast();
 
  plugin = (CbmMvdSensorPlugin*) fPluginArray->At(nPlugin);
  if (nPlugin <= maxPlugin) {
    plugin->ExecChain();
    //cout << endl << "is plugin ready? "<< plugin->PluginReady() << " on sensor "<< this->GetName()  << endl;
    if (plugin->PluginReady()) {
      //cout << endl << "exec chain on sensor "<< this->GetName() << endl;
      for (UInt_t i = nPlugin + 1; i < maxPlugin; i++) {
        //cout << endl << "exec plugin " << i << " on sensor "<< this->GetName() << endl;
        plugin = (CbmMvdSensorPlugin*) fPluginArray->At(i);
        plugin->ExecChain();
      }
    }
  } else {
    cout << endl << "nPlugin to large" << endl;
  }
}
 
// -------------------------------------------------------------------------
TClonesArray* CbmMvdSensor::GetOutputArray(Int_t nPlugin) const {
 
  if (nPlugin == fHitPlugin)
    GetOutputBuffer();
  else if (nPlugin == fDigiPlugin) {
    CbmMvdSensorDigitizerTask* digiplugin =
      (CbmMvdSensorDigitizerTask*) fPluginArray->At(nPlugin);
    Int_t ArrayLength = digiplugin->GetOutputArray()->GetEntriesFast() - 1;
    if (ArrayLength >= 0) {
      foutputDigis->AbsorbObjects(digiplugin->GetOutputArray());
      foutputDigiMatch->AbsorbObjects(digiplugin->GetMatchArray());
      //cout << endl << "got digis " << foutputDigis->GetEntriesFast() << " and matches " << foutputDigiMatch->GetEntriesFast() << endl;
    }
    return (foutputDigis);
  } else if (nPlugin == fClusterPlugin)  //khun not needed
  {
    CbmMvdSensorClusterfinderTask* clusterplugin =
      (CbmMvdSensorClusterfinderTask*) fPluginArray->At(nPlugin);
    Int_t ArrayLength = clusterplugin->GetOutputArray()->GetEntriesFast() - 1;
    if (ArrayLength >= 0)
      foutputCluster->AbsorbObjects(
        clusterplugin->GetOutputArray(), 0, ArrayLength);
    return (foutputCluster);
  } else {
    LOG(fatal) << "undefined plugin: " << nPlugin << " called";
  }
  return NULL;
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
Int_t CbmMvdSensor::GetOutputArrayLen(Int_t nPlugin) const {
 
  GetOutputArray(nPlugin);  // make sure that the arrays are filled
 
  if (nPlugin == fDigiPlugin) {
    return (foutputDigis->GetEntriesFast() - 1);
  }
  //not needed khun
  else if (nPlugin == fClusterPlugin)  // && (noCluster==kFALSE))
  {
    return (foutputCluster->GetEntriesFast() - 1);
  } else if (nPlugin == fHitPlugin) {
    return (foutputBuffer->GetEntriesFast() - 1);
  }
 
  else {
    LOG(fatal) << "undefined plugin called";
    return -1;
  }
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
TClonesArray* CbmMvdSensor::GetOutputMatch() const {
 
  return (foutputDigiMatch);
}
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
TClonesArray* CbmMvdSensor::GetOutputBuffer() const {
 
 
  CbmMvdSensorPlugin* plugin =
    (CbmMvdSensorPlugin*) fPluginArray->At(fPluginArray->GetLast());
  foutputBuffer->AbsorbObjects(plugin->GetOutputArray());
  return (foutputBuffer);
}
// -------------------------------------------------------------------------
 
 
// -----  Coordinate Transformations --------------------------------
 
void CbmMvdSensor::LocalToTop(Double_t* local, Double_t* lab) {
  fMCMatrix->LocalToMaster(local, lab);
};
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::TopToLocal(Double_t* lab, Double_t* local) {
  fMCMatrix->MasterToLocal(lab, local);
  //cout << endl << "local 0 nach TopToLocal " << local[0] << endl;
  //cout << endl << "local 1 nach TopToLocal " << local[1] << endl;
};
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::LocalToPixel(Double_t* local,
                                Int_t& pixelNumberX,
                                Int_t& pixelNumberY) {
 
  //Compute position of the frame relativ to the border of the matrix
  //which contains the pixel (0/0)
  Double_t x = local[0] + (fSensorData->GetPixelSignX() * GetDX());
  //cout << "From " << local[0] << " to Double_t x " << x << endl;
  Double_t y = local[1] + (fSensorData->GetPixelSignY() * GetDY());
  //cout << "From " << local[1] << " to Double_t y " << y << endl;
  //Compute the number of the pixel hit.
  //Note: substract 0.5 to move from border to center of pixel
  pixelNumberX = Int_t(x / fSensorData->GetPixelPitchX() - 0.5);
  //if (pixelNumberX < 0) cout << "pixelNumberX = " << pixelNumberX << " on Sensor " << this->GetName() << endl;
  pixelNumberY = Int_t(y / fSensorData->GetPixelPitchY() - 0.5);
  //if (pixelNumberY < 0) cout << "pixelNumberY = " << pixelNumberY << " on Sensor " << this->GetName() << endl;
};
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::PixelToLocal(Int_t pixelNumberX,
                                Int_t pixelNumberY,
                                Double_t* local) {
 
  //Compute distance from border of the pixel matrix
  //Ignore the direction of pixel numbering so far
  //By definiton (x,y) is in the center of the pixel
 
  Double_t x = (pixelNumberX + 0.5) * fSensorData->GetPixelPitchX();
  Double_t y = (pixelNumberY + 0.5) * fSensorData->GetPixelPitchY();
 
  //Perform coordinate transformation from border of matrix to center of volume
  local[0] = x - fSensorData->GetPixelSignX() * GetDX();
  local[1] = y - fSensorData->GetPixelSignY() * GetDY();
 
  local[2] = 0;  //per definition always at the sensor surface;
};
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
void CbmMvdSensor::PixelToTop(Int_t pixelNumberX,
                              Int_t pixelNumberY,
                              Double_t* lab) {
  PixelToLocal(pixelNumberX, pixelNumberY, fTempCoordinate);
  LocalToTop(fTempCoordinate, lab);
};
// -------------------------------------------------------------------------
 
 
void CbmMvdSensor::TopToPixel(Double_t* lab,
                              Int_t& pixelNumberX,
                              Int_t& pixelNumberY) {
  TopToLocal(lab, fTempCoordinate);
  LocalToPixel(fTempCoordinate, pixelNumberX, pixelNumberY);
};
// -------------------------------------------------------------------------
 
 
// -------------------------------------------------------------------------
Int_t CbmMvdSensor::GetFrameNumber(Int_t pixelNumberY,
                                   Double_t absoluteTime) const {
 
 
  Double_t timeSinceStart = absoluteTime - fSensorStartTime;
 
  Double_t timeInUnitsOfFrames =
    timeSinceStart / fSensorData->GetIntegrationTime();
 
  // Get time substracting the full frames (140.3 -> 0.3)
  Double_t timeSinceStartOfTheFrame =
    timeInUnitsOfFrames - (Int_t) timeInUnitsOfFrames;
 
  Int_t rowUnderReadout =
    Int_t(fSensorData->GetNPixelsY() * timeSinceStartOfTheFrame);
 
 
  return (Int_t)(timeInUnitsOfFrames + (pixelNumberY < rowUnderReadout));
  //
  /* This statement is equivalent to:
  if (pixelNumberY<rowUnderReadout) {return timeInUnitsOfFrames;}
  else                              {return timeInUnitsOfFrames+1;}
  */
}
// -------------------------------------------------------------------------
 
// -------------------------------------------------------------------------
Double_t CbmMvdSensor::GetReadoutTime(Double_t absoluteTime) const {
 
 
  Double_t timeSinceStart = absoluteTime - fSensorStartTime;
 
  Double_t timeInUnitsOfFrames =
    timeSinceStart / fSensorData->GetIntegrationTime();
 
  Int_t nextFrame = (Int_t)(timeInUnitsOfFrames + 1);
 
  Double_t roTime = nextFrame * fSensorData->GetIntegrationTime();
 
  return roTime;
}
// -------------------------------------------------------------------------
 
 
// -----   Public method Print   -------------------------------------------
void CbmMvdSensor::Print(Option_t* /*opt*/) const {
  cout << " --- " << GetName() << ", sensor name" << fVolName << endl;
  cout << " MC - ID: " << fVolumeId << endl;
  cout << "---------------------------------------------------------" << endl;
  cout << " Position information: " << endl;
  fRecoMatrix->Print();
  cout << " --------------------------------------------------------" << endl;
  cout << " Technical information: " << endl;
  fSensorData->Print("");
  cout << " , MC Id " << fVolumeId << endl;
  cout << "---------------------------------------------------------" << endl;
}
// -------------------------------------------------------------------------
 
//-----------------------------------------------------------------------
void CbmMvdSensor::Finish() {
  CbmMvdSensorPlugin* plugin;
  Int_t nPlugin = fPluginArray->GetEntriesFast();
  for (Int_t i = 0; i < nPlugin; i++) {
    plugin = (CbmMvdSensorPlugin*) fPluginArray->At(i);
    plugin->Finish();
  }
}
// -------------------------------------------------------------------------
 
 
ClassImp(CbmMvdSensor)