PndSdsCalcPixel Class Reference

Calculates the pixels (digis) fired from a particle hitting the sensor. More...

#include <PndSdsCalcPixel.h>

Public Member Functions
	PndSdsCalcPixel ()
	Default constructor. More...
	PndSdsCalcPixel (Double_t w, Double_t l, Double_t threshold=0, Double_t noise=0)
std::vector< PndSdsPixel >	GetPixels (Double_t inx, Double_t iny, Double_t outx, Double_t outy, Double_t energy)
	Main function to calculate the vector<PndSdsPixel> of fired pixel. More...
Int_t	GetPixelsAlternative (Double_t inx, Double_t iny, Double_t outx, Double_t outy, Double_t energy, std::vector< Int_t > &cols, std::vector< Int_t > &rows, std::vector< Double_t > &charges)
void	SetVerboseLevel (Int_t level)
std::ostream &	operator<< (std::ostream &out)

Private Types
enum	EQuadrantType {   kQuadUNDEF, kUR, kUL, kDL,   kDR }
enum	ENextPixelType {   kPixelUNDEF, kU, kD, kL,   kR }

Private Member Functions
void	CalcConMatrix ()
void	ApplyConMatrix ()
void	CalcQuadrant ()
void	CalcCperL (Double_t Energy)
void	CalcStartPixel ()
void	CalcPixel ()
void	ConvertPixels ()
Double_t	SmearCharge (Double_t charge)

Private Attributes
std::vector< PndSdsPixel >	fPixels
Double_t	fPixelWidth
Double_t	fPixelLength
Double_t	fThreshold
Double_t	fNoise
Double_t	fEnergy
Int_t	fVerboseLevel
EQuadrantType	fQuad
ENextPixelType	fNextPixel
FairGeoVector	fIn
FairGeoVector	fOut
FairGeoVector	fDir
FairGeoVector	fPos
FairGeoVector	fCon
PndSdsPixel	fActivePixel
Double_t	fCperL
bool	fStop

Detailed Description

Calculates the pixels (digis) fired from a particle hitting the sensor.

Author

Tobias Stockmanns t.sto.nosp@m.ckma.nosp@m.nns@f.nosp@m.z-ju.nosp@m.elich.nosp@m..de This class gets as an input the point where the particle enters the sensor, where it leaves the sensor and the deposited energy. It calculates the track of the particle between these two points and determines the pixels lying on the track. The total energy of the particle is then distributed acording to the pathlength to the pixels. The output is a vector<PndSdsPixel> of the fired sensor pixels with the energy deposited in the pixels. If a noise value is given a gausian distributed energy with a sigma of (noise) is added (or substracted) to the energy deposited in one pixel. If a threshold value is given all pixels with energies below threshold are ignored

Definition at line 23 of file PndSdsCalcPixel.h.

Member Enumeration Documentation

enum PndSdsCalcPixel::ENextPixelType

private

Enumerator
kPixelUNDEF
kU
kD
kL
kR

Definition at line 56 of file PndSdsCalcPixel.h.

{kPixelUNDEF, kU, kD, kL, kR} ENextPixelType;

enum PndSdsCalcPixel::EQuadrantType

private

Enumerator
kQuadUNDEF
kUR
kUL
kDL
kDR

Definition at line 55 of file PndSdsCalcPixel.h.

{kQuadUNDEF, kUR, kUL, kDL, kDR} EQuadrantType;

Constructor & Destructor Documentation

PndSdsCalcPixel::PndSdsCalcPixel

(

)

Default constructor.

Definition at line 6 of file PndSdsCalcPixel.cxx.

                                 :
  fPixels(),
  fPixelWidth(0.),
  fPixelLength(0.),
  fThreshold(0.),
  fNoise(0.),
  fEnergy(0.),
  fVerboseLevel(0),
  fQuad(kQuadUNDEF),
  fNextPixel(kPixelUNDEF),
  fIn(),
  fOut(),
  fDir(),
  fPos(),
  fCon(),
  fActivePixel(),
  fCperL(-1),
  fStop(false)
{
}

PndSdsCalcPixel::PndSdsCalcPixel	(	Double_t	w,
		Double_t	l,
		Double_t	threshold = 0,
		Double_t	noise = 0
	)

Main constructor

Parameters

w	width of sensor pixel [cm]
l	length of sensor pixel [cm]
threshold	discriminator threshold of pixel [e]
noise	total noise of pixel [e]

Definition at line 27 of file PndSdsCalcPixel.cxx.

                                                                                           :
  fPixels(),
  fPixelWidth(w),
  fPixelLength(l),
  fThreshold(threshold),
  fNoise(noise),
  fEnergy(0.),
  fVerboseLevel(0),
  fQuad(kQuadUNDEF),
  fNextPixel(kPixelUNDEF),
  fIn(),
  fOut(),
  fDir(),
  fPos(),
  fCon(),
  fActivePixel(),
  fCperL(-1),
  fStop(false)
{}

Member Function Documentation

void PndSdsCalcPixel::ApplyConMatrix ( )

private

Definition at line 121 of file PndSdsCalcPixel.cxx.

References fCon, fDir, fIn, fOut, and fPos.

{
  fIn.setX(fCon.getX() * fIn.getX());
  fIn.setY(fCon.getY() * fIn.getY());
  
  fOut.setX(fCon.getX() * fOut.getX());
  fOut.setY(fCon.getY() * fOut.getY());
  
  fPos.setX(fCon.getX() * fPos.getX());
  fPos.setY(fCon.getY() * fPos.getY());
  
  fDir.setX(fCon.getX() * fDir.getX());
  fDir.setY(fCon.getY() * fDir.getY());
  
}

void PndSdsCalcPixel::CalcConMatrix ( )

private

Definition at line 111 of file PndSdsCalcPixel.cxx.

References fCon, and fIn.

{
  if (fIn.getX() < 0)
    fCon.setX(-1);
  else fCon.setX(1);
  if (fIn.getY() < 0)
    fCon.setY(-1);
  else fCon.setY(1);
}

void PndSdsCalcPixel::CalcCperL ( Double_t  Energy )

private

Definition at line 154 of file PndSdsCalcPixel.cxx.

References Double_t, fCperL, and fDir.

Referenced by GetPixels().

{
  Double_t Charge = Energy / (3.61e-9);
  fCperL = Charge / fDir.length();  
}

void PndSdsCalcPixel::CalcPixel ( )

private

Definition at line 168 of file PndSdsCalcPixel.cxx.

References Double_t, fabs(), fActivePixel, fCperL, fDir, fNextPixel, fOut, fPixelLength, fPixels, fPixelWidth, fPos, fQuad, fStop, fThreshold, fVerboseLevel, PndSdsPixel::GetCol(), PndSdsPixel::GetRow(), kD, kDL, kDR, kL, kQuadUNDEF, kR, kU, kUL, kUR, printf(), PndSdsPixel::SetCharge(), and SmearCharge().

Referenced by GetPixels().

{
  Double_t borderX = 0;
  Double_t borderY = 0;
  FairGeoVector OutPoint;
  bool xBeforeY = false;
  
  /*  if ( fabs(fDir.getX()) < 1e-8 ) {
   xBeforeY = false;
   borderY = fPixelWidth * (fActivePixel.GetRow()+1);
   }
   else  if ( fabs(fDir.getY()) < 1e-8 ) {
   xBeforeY = true;
   borderX = fPixelWidth
   }
   else  switch (fQuad){
   */
  switch (fQuad){
    case kUR : borderX = fPixelLength * (fActivePixel.GetCol()+1);
      borderY = fPixelWidth  * (fActivePixel.GetRow()+1);
      if ( fabs(fDir.getX()) < 1e-8 ) xBeforeY = false;
      else if ( ( (borderX - fPos.getX()) * fDir.getY() / fDir.getX() )+fPos.getY() < borderY)
        xBeforeY = true;
      else xBeforeY = false;
      break;
    case kUL : borderX = fPixelLength * (fActivePixel.GetCol());
      borderY = fPixelWidth  * (fActivePixel.GetRow()+1);
      if ( fabs(fDir.getX()) < 1e-8 ) xBeforeY = false;
      else if ( ( (borderX - fPos.getX()) * fDir.getY() / fDir.getX() )+fPos.getY() < borderY)
        xBeforeY = true;
      else xBeforeY = false;
      break;
    case kDL : borderX = fPixelLength * (fActivePixel.GetCol());
      borderY = fPixelWidth  * (fActivePixel.GetRow());
      if ( fabs(fDir.getX()) < 1e-8 ) xBeforeY = false;
      else if ( ( (borderX - fPos.getX()) * fDir.getY() / fDir.getX() )+fPos.getY() > borderY)
        xBeforeY = true;
      else xBeforeY = false;
      break;
    case kDR : borderX = fPixelLength * (fActivePixel.GetCol()+1);
      borderY = fPixelWidth  * (fActivePixel.GetRow());
      if ( fabs(fDir.getX()) < 1e-8 ) xBeforeY = false;
      else if ( ( (borderX - fPos.getX()) * fDir.getY() / fDir.getX() )+fPos.getY() > borderY)
        xBeforeY = true;
      else xBeforeY = false;
      break;
    case kQuadUNDEF : std::cout<<"PndSdsCalcPixel::CalcPixel : Quadrant not defined!"<<std::endl;
      //default : ErrMsg(fatal) << " Quadrant not defined! " << endmsg;
  }
  
  if ( xBeforeY ) { //Is borderX reached berfore borderY
    OutPoint.setXYZ(borderX, ((borderX-fPos.getX())*fDir.getY()/fDir.getX())+fPos.getY(),0);
    
    if (fQuad == kUR || fQuad == kDR)
      fNextPixel = kR;
    else fNextPixel = kL;
  }
  else {
    OutPoint.setXYZ(((borderY-fPos.getY())*fDir.getX()/fDir.getY())+fPos.getX(), borderY,0);
    
    if (fQuad == kUR || fQuad == kUL)
      fNextPixel = kU;
    else fNextPixel = kD;
  } 
  //  ErrMsg(warning) << " OutPoint: " << OutPoint << endmsg;
  
  
  if ((OutPoint - fPos).length() > (fOut - fPos).length()){
    fStop = true;
    OutPoint = fOut;
  }
  
  
  Double_t depCharge = (OutPoint - fPos).length() * fCperL;
  if (fVerboseLevel > 1){
    printf("len: %g, cperL: %g, depCharge w/o noise: %g\n",(OutPoint - fPos).length(),fCperL,depCharge);
  }
  
  // noise smearing and discriminator threshold cut
  Double_t smearedCharge = SmearCharge(depCharge);
  if (smearedCharge<=fThreshold) return;
  
  fPos = OutPoint;
  fActivePixel.SetCharge(smearedCharge);
  
  
  fPixels.push_back(fActivePixel);
  
  if (fVerboseLevel > 1){
    std::cout << fActivePixel << std::endl;
  }
  
}

void PndSdsCalcPixel::CalcQuadrant ( )

private

Definition at line 137 of file PndSdsCalcPixel.cxx.

References fDir, fQuad, fVerboseLevel, kDL, kDR, kUL, and kUR.

Referenced by GetPixels().

{
  if (fDir.getX() > 0)
    if (fDir.getY() > 0)
      fQuad = kUR;
    else
      fQuad = kDR;
    else if (fDir.getY() > 0)
      fQuad = kUL;
    else
      fQuad = kDL;
  
  if (fVerboseLevel > 1){
    std::cout << "CalcQuadrant: " << fQuad << std::endl;
  }
}

void PndSdsCalcPixel::CalcStartPixel ( )

private

Definition at line 160 of file PndSdsCalcPixel.cxx.

References col, fActivePixel, fIn, fPixelLength, fPixelWidth, row, PndSdsPixel::SetCol(), and PndSdsPixel::SetRow().

Referenced by GetPixels().

{
  Int_t col = Int_t(fIn.getX() / fPixelLength);
  Int_t row = Int_t(fIn.getY() / fPixelWidth);
  fActivePixel.SetCol(col);
  fActivePixel.SetRow(row);
}

void PndSdsCalcPixel::ConvertPixels ( )

private

Definition at line 262 of file PndSdsCalcPixel.cxx.

References col, fCon, fPixels, i, and row.

{
  Int_t col, row;
  for (UInt_t i = 0; i < fPixels.size(); i++){
    col = fPixels[i].GetCol();
    row = fPixels[i].GetRow();
    fPixels[i].SetCol(Int_t(col * fCon.getX()));
    fPixels[i].SetRow(Int_t(row * fCon.getY()));
  }
}

std::vector< PndSdsPixel > PndSdsCalcPixel::GetPixels	(	Double_t	inx,
		Double_t	iny,
		Double_t	outx,
		Double_t	outy,
		Double_t	energy
	)

Main function to calculate the vector<PndSdsPixel> of fired pixel.

Definition at line 66 of file PndSdsCalcPixel.cxx.

References CalcCperL(), CalcPixel(), CalcQuadrant(), CalcStartPixel(), col, fActivePixel, fDir, fIn, fNextPixel, fOut, fPixels, fPos, fStop, fVerboseLevel, PndSdsPixel::GetCol(), PndSdsPixel::GetRow(), kD, kL, kPixelUNDEF, kR, kU, row, PndSdsPixel::SetCharge(), PndSdsPixel::SetCol(), and PndSdsPixel::SetRow().

Referenced by PndSdsHybridHitProducer::Exec(), and GetPixelsAlternative().

{
  fPixels.clear();
  fIn.setXYZ(inx, iny, 0);
  fOut.setXYZ(outx, outy, 0);
  
  fDir = fOut - fIn;
  fPos = fIn;
  if (fDir.length() < 0.001){   //1 m
    CalcStartPixel();
    fActivePixel.SetCharge(energy/(3.61e-9));
    fPixels.push_back(fActivePixel);
    return fPixels;
  }
  //  CalcConMatrix(); //fCon berechnen
  //  ApplyConMatrix(); //fCon anwenden
  if (fVerboseLevel > 1){
    std::cout << "Converted Vectors: " << std::endl;
    std::cout << fIn << fOut << fDir << fPos << std::endl;
  }
  CalcQuadrant();
  CalcCperL(energy);
  
  CalcStartPixel();
  
  fStop = false;
  while (fStop != true){
    CalcPixel();
    Int_t col = fActivePixel.GetCol();
    Int_t row = fActivePixel.GetRow();
    switch (fNextPixel) {
      case kU : fActivePixel.SetRow(++row); break;
      case kD : fActivePixel.SetRow(--row); break;
      case kL : fActivePixel.SetCol(--col); break;
      case kR : fActivePixel.SetCol(++col); break;
      case kPixelUNDEF : std::cout << "PndSdsCalcPixel::GetPixels no next pixel."<<std::endl; break;
    }
    fActivePixel.SetCharge(-1.0);
  }
  
  //  ConvertPixels(); //fCon rueckgaengig
  return fPixels;
}

Int_t PndSdsCalcPixel::GetPixelsAlternative	(	Double_t	inx,
		Double_t	iny,
		Double_t	outx,
		Double_t	outy,
		Double_t	energy,
		std::vector< Int_t > &	cols,
		std::vector< Int_t > &	rows,
		std::vector< Double_t > &	charges
	)

Definition at line 47 of file PndSdsCalcPixel.cxx.

References fVerboseLevel, GetPixels(), and i.

{
  std::vector<PndSdsPixel> pixels = GetPixels(inx,iny,outx,outy,energy);
  Int_t npix=pixels.size();
  for(Int_t i=0;i<npix;i++)
  { 
    if(fVerboseLevel>2) Info("PndSdsCalcPixel::GetPixelsAlternative()","pass this pixel: i=%i, c=%i, r=%i, q=%f",i,pixels[i].GetCol(),pixels[i].GetRow(),pixels[i].GetCharge());
    cols.push_back(pixels[i].GetCol());
    rows.push_back(pixels[i].GetRow());
    charges.push_back(pixels[i].GetCharge());
  }
  return npix;
}

std::ostream & PndSdsCalcPixel::operator<<

(

std::ostream &

out

)

Definition at line 273 of file PndSdsCalcPixel.cxx.

References fPixelLength, fPixelWidth, and out.

{
  out << "PixelWidth: " << fPixelWidth << " PixelLength: " <<
  fPixelLength << std::endl;
  
  return out;
}

void PndSdsCalcPixel::SetVerboseLevel ( Int_t  level )

inline

Definition at line 44 of file PndSdsCalcPixel.h.

References fVerboseLevel.

{ fVerboseLevel = level;};

Double_t PndSdsCalcPixel::SmearCharge ( Double_t  charge )

private

Definition at line 282 of file PndSdsCalcPixel.cxx.

References Double_t, fNoise, and fVerboseLevel.

Referenced by CalcPixel().

{
  Double_t smeared = gRandom->Gaus(charge,fNoise);
  if (fVerboseLevel > 3) std::cout<<" charge = "<<charge<<", smeared = "<<smeared<<std::endl;
  return smeared;
}

Member Data Documentation

PndSdsPixel PndSdsCalcPixel::fActivePixel

private

Definition at line 68 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), CalcStartPixel(), and GetPixels().

FairGeoVector PndSdsCalcPixel::fCon

private

Definition at line 66 of file PndSdsCalcPixel.h.

Referenced by ApplyConMatrix(), CalcConMatrix(), and ConvertPixels().

Double_t PndSdsCalcPixel::fCperL

private

Definition at line 69 of file PndSdsCalcPixel.h.

Referenced by CalcCperL(), and CalcPixel().

FairGeoVector PndSdsCalcPixel::fDir

private

Definition at line 63 of file PndSdsCalcPixel.h.

Referenced by ApplyConMatrix(), CalcCperL(), CalcPixel(), CalcQuadrant(), and GetPixels().

Double_t PndSdsCalcPixel::fEnergy

private

Definition at line 52 of file PndSdsCalcPixel.h.

FairGeoVector PndSdsCalcPixel::fIn

private

Definition at line 61 of file PndSdsCalcPixel.h.

Referenced by ApplyConMatrix(), CalcConMatrix(), CalcStartPixel(), and GetPixels().

ENextPixelType PndSdsCalcPixel::fNextPixel

private

Definition at line 59 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), and GetPixels().

Double_t PndSdsCalcPixel::fNoise

private

Definition at line 51 of file PndSdsCalcPixel.h.

Referenced by SmearCharge().

FairGeoVector PndSdsCalcPixel::fOut

private

Definition at line 62 of file PndSdsCalcPixel.h.

Referenced by ApplyConMatrix(), CalcPixel(), and GetPixels().

Double_t PndSdsCalcPixel::fPixelLength

private

Definition at line 49 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), CalcStartPixel(), and operator<<().

std::vector<PndSdsPixel> PndSdsCalcPixel::fPixels

private

Definition at line 47 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), ConvertPixels(), and GetPixels().

Double_t PndSdsCalcPixel::fPixelWidth

private

Definition at line 48 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), CalcStartPixel(), and operator<<().

FairGeoVector PndSdsCalcPixel::fPos

private

Definition at line 64 of file PndSdsCalcPixel.h.

Referenced by ApplyConMatrix(), CalcPixel(), and GetPixels().

EQuadrantType PndSdsCalcPixel::fQuad

private

Definition at line 58 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), and CalcQuadrant().

bool PndSdsCalcPixel::fStop

private

Definition at line 70 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), and GetPixels().

Double_t PndSdsCalcPixel::fThreshold

private

Definition at line 50 of file PndSdsCalcPixel.h.

Referenced by CalcPixel().

Int_t PndSdsCalcPixel::fVerboseLevel

private

Definition at line 53 of file PndSdsCalcPixel.h.

Referenced by CalcPixel(), CalcQuadrant(), GetPixels(), GetPixelsAlternative(), SetVerboseLevel(), and SmearCharge().

---

The documentation for this class was generated from the following files:

• PndSdsCalcPixel.h
• PndSdsCalcPixel.cxx