PndGemSensorMonitor Class Reference

#include <PndGemSensorMonitor.h>

Inheritance diagram for PndGemSensorMonitor:

Public Member Functions
	PndGemSensorMonitor ()
	PndGemSensorMonitor (TString tempName, Int_t detId, Int_t iType, Double_t x0, Double_t y0, Double_t z0, Double_t rotation, Double_t innerRad, Double_t outerRad, Double_t d, Double_t stripAngle0, Double_t stripAngle1, Double_t pitch0, Double_t pitch1)
	PndGemSensorMonitor (TString tempName, Int_t stationNr, Int_t sectorNr, Int_t iType, Double_t x0, Double_t y0, Double_t z0, Double_t rotation, Double_t innerRad, Double_t outerRad, Double_t d, Double_t stripAngle0, Double_t stripAngle1, Double_t pitch0, Double_t pitch1)
	PndGemSensorMonitor (const PndGemSensor &tempSensor)
virtual	~PndGemSensorMonitor ()
void	ActivateChannel (Int_t channelNr, Int_t sideId, Int_t eventNr, Int_t digiNr, Double_t channelTime, Double_t channelCharge)
void	CheckNeighbours (Int_t channelNr, Int_t sideId, Int_t eventNr, Int_t digiNr, Double_t channelTime, Double_t channelCharge)
Bool_t	ChannelIsActive (Int_t channelNr, Int_t sideId, Double_t timeNow)
Double_t	ChannelLastActiveAt (Int_t channelNr, Int_t sideId, Double_t timeNow, Int_t eventNr=-1)
Double_t	ChannelLastActiveAt (Int_t channelNr, Int_t sideId)
Bool_t	ChannelLastActivation (Int_t channelNr, Int_t sideId, Int_t &eventNr, Int_t &digiNr, Double_t &channelTime, Double_t &channelCharge)
void	Print ()
TString	GetDetectorName () const
void	SetDetectorId (Int_t stationNr, Int_t sensorNr)
Int_t	GetDetectorId () const
Int_t	GetSystemId () const
Int_t	GetStationNr () const
Int_t	GetSensorNr () const
Int_t	GetType () const
Double_t	GetX0 () const
Double_t	GetY0 () const
Double_t	GetZ0 () const
Double_t	GetRotation () const
Double_t	GetInnerRadius () const
Double_t	GetOuterRadius () const
Double_t	GetD () const
Double_t	GetStripAngle (Int_t index) const
Double_t	GetPitch (Int_t index) const
Double_t	GetSigmaX () const
Double_t	GetSigmaY () const
Double_t	GetSigmaXY () const
Int_t	GetNChannels () const
Int_t	GetNChannelsFront () const
Int_t	GetNChannelsBack () const
Int_t	GetSideChannels (Int_t si) const
Int_t	GetChannel (Double_t x, Double_t y, Int_t iSide)
Int_t	GetChannel2 (Double_t x, Double_t y, Int_t iSide, Double_t &feeDist)
Bool_t	Inside (Double_t x, Double_t y)
Bool_t	Inside (Double_t radius)
Double_t	GetStripOrientation (Double_t x, Double_t y, Int_t iSide)
Double_t	GetDistance (Int_t iSide, Double_t chan1, Double_t chan2)
Int_t	GetDistance (Int_t iSide, Int_t chanMin, Int_t chanMax, Int_t chanTest)
Double_t	GetDistance2 (Int_t iSide, Double_t chan1, Double_t chan2)
Int_t	GetSensorPart (Int_t iSide, Int_t chan)
Double_t	GetMeanChannel (Int_t iSide, Double_t chan1, Double_t weight1, Double_t chan2, Double_t weight2)
Int_t	GetNeighbours (Int_t iSide, Int_t iChan, Int_t &nChan1, Int_t &nChan2, Int_t &nChan3)
Int_t	Intersect (Double_t iFStrip, Double_t iBStrip, Double_t &xCross, Double_t &yCross, Double_t &zCross)
Int_t	Intersect (Double_t iFStrip, Double_t iBStrip, Double_t &xCross, Double_t &yCross, Double_t &zCross, Double_t &dr, Double_t &dp)
Int_t	Intersect (Double_t iFStrip, Double_t iBStrip, Double_t &xCross, Double_t &yCross, Double_t &zCross, Double_t &dx, Double_t &dy, Double_t &dr, Double_t &dp)
void	Reset ()

Private Member Functions
	ClassDef (PndGemSensorMonitor, 1)

Private Attributes
std::vector< Double_t >	fFLATime
std::vector< Double_t >	fFLACharge
std::vector< Int_t >	fFLADigiNr
std::vector< Int_t >	fFLAEventNr
std::vector< Double_t >	fFMeanTimeD
std::vector< Int_t >	fFNofDigis
Int_t	fFSLChan
std::vector< Double_t >	fBLATime
std::vector< Double_t >	fBLACharge
std::vector< Int_t >	fBLADigiNr
std::vector< Int_t >	fBLAEventNr
std::vector< Double_t >	fBMeanTimeD
std::vector< Int_t >	fBNofDigis
Int_t	fBSLChan
Double_t	fSensorRecoveryTime
Double_t	fSensorFirstTime
Double_t	fSensorLastTime

Detailed Description

PndGemSensor.h

Author

Radoslaw Karabowicz r.kar.nosp@m.abow.nosp@m.icz@g.nosp@m.si.d.nosp@m.e

Since

25/03/2013

Version

1.0

This class monitors the digis in the sensor, on front and back. It derives from PndGemSensor, so that we have information about number of digis, positions and so on.

Definition at line 30 of file PndGemSensorMonitor.h.

Constructor & Destructor Documentation

PndGemSensorMonitor::PndGemSensorMonitor

(

)

Default constructor

Definition at line 25 of file PndGemSensorMonitor.cxx.

                                         : 
  PndGemSensor(),
  fFLATime(0),
  fFLACharge(0),
  fFLADigiNr(0),
  fFLAEventNr(0),
  fFMeanTimeD(0),
  fFNofDigis(0),
  fFSLChan(0),
  fBLATime(0),
  fBLACharge(0),
  fBLADigiNr(0),
  fBLAEventNr(0),
  fBMeanTimeD(0),
  fBNofDigis(0),
  fBSLChan(0),
  fSensorRecoveryTime(100.),
  fSensorFirstTime(0.),
  fSensorLastTime(0.)
{
}

PndGemSensorMonitor::PndGemSensorMonitor	(	TString	tempName,
		Int_t	detId,
		Int_t	iType,
		Double_t	x0,
		Double_t	y0,
		Double_t	z0,
		Double_t	rotation,
		Double_t	innerRad,
		Double_t	outerRad,
		Double_t	d,
		Double_t	stripAngle0,
		Double_t	stripAngle1,
		Double_t	pitch0,
		Double_t	pitch1
	)

Standard constructor

Parameters

fName	Unique sensor name
detId	Unique detector identifier
iType	Sensor type (1,2,3)
pos[]	sensor centre coordinate in global c.s [cm]
rotation	rotation in global c.s. [rad]
innerRadius	sensor inner radius in [cm]
outerRadius	sensor outer radius in [cm]
d	sensor thickness in [cm]
stripAngle[]	strip angle, if 0 - radial strips, measuring theta, if 60 - modified radial strips, joining inner ring with outer rotated by 60 deg. if 90 - concentric strips, measuring radius
pitch[]	readout radial/angle strip pitch or pixel width in x/y [cm]

Definition at line 51 of file PndGemSensorMonitor.cxx.

                                                                           :
  PndGemSensor(tempName,detId,iType,x0,y0,z0,rotation,innerRad,outerRad,d,stripAngle0,stripAngle1,pitch0,pitch1),
  fFLATime(0),
  fFLACharge(0),
  fFLADigiNr(0),
  fFLAEventNr(0),
  fFMeanTimeD(0),
  fFNofDigis(0),
  fFSLChan(0),
  fBLATime(0),
  fBLACharge(0),
  fBLADigiNr(0),
  fBLAEventNr(0),
  fBMeanTimeD(0),
  fBNofDigis(0),
  fBSLChan(0),
  fSensorRecoveryTime(100.),
  fSensorFirstTime(0.),
  fSensorLastTime(0.)
{
}

PndGemSensorMonitor::PndGemSensorMonitor	(	TString	tempName,
		Int_t	stationNr,
		Int_t	sectorNr,
		Int_t	iType,
		Double_t	x0,
		Double_t	y0,
		Double_t	z0,
		Double_t	rotation,
		Double_t	innerRad,
		Double_t	outerRad,
		Double_t	d,
		Double_t	stripAngle0,
		Double_t	stripAngle1,
		Double_t	pitch0,
		Double_t	pitch1
	)

Definition at line 81 of file PndGemSensorMonitor.cxx.

References fBLACharge, fBLADigiNr, fBLAEventNr, fBLATime, fBMeanTimeD, fBNofDigis, fFLACharge, fFLADigiNr, fFLAEventNr, fFLATime, fFMeanTimeD, fFNofDigis, PndGemSensor::GetNChannelsBack(), and PndGemSensor::GetNChannelsFront().

                                                                           :
  PndGemSensor(tempName,stationNr,sectorNr,iType,x0,y0,z0,rotation,innerRad,outerRad,d,stripAngle0,stripAngle1,pitch0,pitch1),
  fFLATime(0),
  fFLACharge(0),
  fFLADigiNr(0),
  fFLAEventNr(0),
  fFMeanTimeD(0),
  fFNofDigis(0),
  fFSLChan(0),
  fBLATime(0),
  fBLACharge(0),
  fBLADigiNr(0),
  fBLAEventNr(0),
  fBMeanTimeD(0),
  fBNofDigis(0),
  fBSLChan(0),
  fSensorRecoveryTime(100.),
  fSensorFirstTime(0.),
  fSensorLastTime(0.)
{
  fFLATime   .resize(this->GetNChannelsFront(),-1.);
  fFLACharge .resize(this->GetNChannelsFront(),-1.);
  fFLADigiNr .resize(this->GetNChannelsFront(),-1);
  fFLAEventNr.resize(this->GetNChannelsFront(),-1);
  fFMeanTimeD.resize(this->GetNChannelsFront(), 0.);
  fFNofDigis .resize(this->GetNChannelsFront(), 0);
  fBLATime   .resize(this->GetNChannelsBack (),-1.);
  fBLACharge .resize(this->GetNChannelsBack (),-1.);
  fBLADigiNr .resize(this->GetNChannelsBack (),-1);
  fBLAEventNr.resize(this->GetNChannelsBack (),-1);
  fBMeanTimeD.resize(this->GetNChannelsBack (), 0.);
  fBNofDigis .resize(this->GetNChannelsBack (), 0);
}

PndGemSensorMonitor::PndGemSensorMonitor

(

const PndGemSensor &

tempSensor

)

Definition at line 123 of file PndGemSensorMonitor.cxx.

References fBLACharge, fBLADigiNr, fBLAEventNr, fBLATime, fBMeanTimeD, fBNofDigis, fFLACharge, fFLADigiNr, fFLAEventNr, fFLATime, fFMeanTimeD, fFNofDigis, PndGemSensor::GetNChannelsBack(), and PndGemSensor::GetNChannelsFront().

                                                                       :
  PndGemSensor(tempSensor),
  fFLATime(0),
  fFLACharge(0),
  fFLADigiNr(0),
  fFLAEventNr(0),
  fFMeanTimeD(0),
  fFNofDigis(0),
  fFSLChan(0),
  fBLATime(0),
  fBLACharge(0),
  fBLADigiNr(0),
  fBLAEventNr(0),
  fBMeanTimeD(0),
  fBNofDigis(0),
  fBSLChan(0),
  fSensorRecoveryTime(100.),
  fSensorFirstTime(0.),
  fSensorLastTime(0.)
{
  fFLATime   .resize(this->GetNChannelsFront(),-1.);
  fFLACharge .resize(this->GetNChannelsFront(),-1.);
  fFLADigiNr .resize(this->GetNChannelsFront(),-1);
  fFLAEventNr.resize(this->GetNChannelsFront(),-1);
  fFMeanTimeD.resize(this->GetNChannelsFront(), 0.);
  fFNofDigis .resize(this->GetNChannelsFront(), 0);
  fBLATime   .resize(this->GetNChannelsBack (),-1.);
  fBLACharge .resize(this->GetNChannelsBack (),-1.);
  fBLADigiNr .resize(this->GetNChannelsBack (),-1);
  fBLAEventNr.resize(this->GetNChannelsBack (),-1);
  fBMeanTimeD.resize(this->GetNChannelsBack (), 0.);
  fBNofDigis .resize(this->GetNChannelsBack (), 0);
}

PndGemSensorMonitor::~PndGemSensorMonitor ( )

virtual

Destructor

Definition at line 160 of file PndGemSensorMonitor.cxx.

{ }

Member Function Documentation

void PndGemSensorMonitor::ActivateChannel	(	Int_t	channelNr,
		Int_t	sideId,
		Int_t	eventNr,
		Int_t	digiNr,
		Double_t	channelTime,
		Double_t	channelCharge
	)

Modifiers

Definition at line 164 of file PndGemSensorMonitor.cxx.

References CheckNeighbours(), Double_t, fBLACharge, fBLADigiNr, fBLAEventNr, fBLATime, fBMeanTimeD, fBNofDigis, fBSLChan, fFLACharge, fFLADigiNr, fFLAEventNr, fFLATime, fFMeanTimeD, fFNofDigis, and fFSLChan.

                                                                                                                                                  {
  if ( sideId == 0 ) {
    // had to comment it out. but be careful with stat options here: if this function is called from PndGemFindHits
    // while looping over clusters, it will cause problems, as digis may belong to different clusters....

    // if ( channelTime > fFLATime[fFSLChan] + 21 && fFLATime[fFSLChan] > -0.5 ) {
    //   cout << "SENSOR " << GetStationNr() << "." << GetSensorNr() << ".F not hitted for " << channelTime-fFLATime[fFSLChan] << " ns (from  "
    //     << fFLATime[fFSLChan] << " to " << channelTime << ")"
    //     << " EVENT " << fFLAEventNr[fFSLChan] << " vs " << eventNr << endl;
    // }
    // if ( fFLAEventNr[channelNr] == eventNr ) {
    //   cout << "****** " << GetStationNr() << "." << GetSensorNr() << ".F hitted twice after " << channelTime-fFLATime[channelNr] << " ns (at  "
    //     << fFLATime[channelNr] << " and " << channelTime << ")"
    //     << " IN EVENT " << eventNr << endl;
    // }
    if ( fFNofDigis[channelNr] > 0 ) {
      fFMeanTimeD[channelNr]  = fFMeanTimeD[channelNr] + (channelTime-fFLATime[channelNr]-fFMeanTimeD[channelNr])/((Double_t)fFNofDigis[channelNr]);
    }
    fFLATime   [channelNr]  = channelTime;
    fFLACharge [channelNr]  = channelCharge;
    fFLADigiNr [channelNr]  = digiNr;
    fFLAEventNr[channelNr]  = eventNr;
    fFNofDigis [channelNr] += 1;
    fFSLChan                = channelNr;
  }
  else {
    // if ( channelTime > fBLATime[fBSLChan] + 21 && fBLATime[fFSLChan] > -0.5  ) {
    //   cout << "SENSOR " << GetStationNr() << "." << GetSensorNr() << ".B not hitted for " << channelTime-fBLATime[fBSLChan] << " ns (from " 
    //     << fBLATime[fBSLChan] << " to " << channelTime << ")"
    //     << " EVENT " << fBLAEventNr[fBSLChan] << " vs " << eventNr << endl;
    // }
    // if ( fBLAEventNr[channelNr] == eventNr ) {
    //   cout << "****** " << GetStationNr() << "." << GetSensorNr() << ".F hitted twice after " << channelTime-fBLATime[channelNr] << " ns (at  "
    //     << fBLATime[channelNr] << " and " << channelTime << ")"
    //     << " IN EVENT " << eventNr << endl;
    // }
    if ( fBNofDigis[channelNr] > 0 ) {
      fBMeanTimeD[channelNr]  = fBMeanTimeD[channelNr] + (channelTime-fBLATime[channelNr]-fBMeanTimeD[channelNr])/((Double_t)fBNofDigis[channelNr]);
    }
    fBLATime   [channelNr]  = channelTime;
    fBLACharge [channelNr]  = channelCharge;
    fBLADigiNr [channelNr]  = digiNr;
    fBLAEventNr[channelNr]  = eventNr;
    fBNofDigis [channelNr] += 1;
    fBSLChan                = channelNr;
  }
  CheckNeighbours(channelNr, sideId, eventNr, digiNr, channelTime, channelCharge);
}

Bool_t PndGemSensorMonitor::ChannelIsActive	(	Int_t	channelNr,
		Int_t	sideId,
		Double_t	timeNow
	)

Accessors

Definition at line 231 of file PndGemSensorMonitor.cxx.

                                                                         { // channelNr sideId timeNow   //[R.K.03/2017] unused variable(s)
  // Empty function!!
  return kFALSE;
}

Bool_t PndGemSensorMonitor::ChannelLastActivation	(	Int_t	channelNr,
		Int_t	sideId,
		Int_t &	eventNr,
		Int_t &	digiNr,
		Double_t &	channelTime,
		Double_t &	channelCharge
	)

Definition at line 279 of file PndGemSensorMonitor.cxx.

                                                                                                          { // channelNr sideId eventNr digiNr channelTime channelCharge //[R.K.03/2017] unused variable(s)
  // Empty function
  return kFALSE;
}

Double_t PndGemSensorMonitor::ChannelLastActiveAt	(	Int_t	channelNr,
		Int_t	sideId,
		Double_t	timeNow,
		Int_t	eventNr = -1
	)

Definition at line 258 of file PndGemSensorMonitor.cxx.

References fBLATime, and fFLATime.

Referenced by PndGemMonitor::ChannelLastActiveAt().

                                                                                                         { // eventNr //[R.K.03/2017] unused variable(s)
  if ( sideId == 0 && fFLATime[channelNr] < -0.5 ) return -1.;
  if ( sideId == 1 && fBLATime[channelNr] < -0.5 ) return -1.;

  if ( sideId == 0 ) {
    // if ( eventNr == fFLAEventNr[channelNr] ) 
    //   cout << "channel " << channelNr << " in sensor " << GetStationNr() << "." << GetSensorNr() << ".F, two hits in ev " << eventNr 
    //     << " 1st @ " << fFLATime[channelNr] << ", now @ " << timeNow << " (diffr=" << timeNow-fFLATime[channelNr] << ")" << endl;
    return timeNow-fFLATime[channelNr];
  }
  else {
    // if ( eventNr == fBLAEventNr[channelNr] ) 
    //   cout << "channel " << channelNr << " in sensor " << GetStationNr() << "." << GetSensorNr() << ".B, two hits in ev " << eventNr 
    //     << " 1st @ " << fBLATime[channelNr] << ", now @ " << timeNow << " (diffr=" << timeNow-fBLATime[channelNr] << ")" << endl;
    return timeNow-fBLATime[channelNr];
  }

}

Double_t PndGemSensorMonitor::ChannelLastActiveAt	(	Int_t	channelNr,
		Int_t	sideId
	)

Definition at line 238 of file PndGemSensorMonitor.cxx.

References fBLATime, and fFLATime.

                                                                               {
  if ( sideId == 0 && fFLATime[channelNr] < -0.5 ) return -1.;
  if ( sideId == 1 && fBLATime[channelNr] < -0.5 ) return -1.;

  if ( sideId == 0 ) {
    // if ( eventNr == fFLAEventNr[channelNr] ) 
    //   cout << "channel " << channelNr << " in sensor " << GetStationNr() << "." << GetSensorNr() << ".F, two hits in ev " << eventNr 
    //     << " 1st @ " << fFLATime[channelNr] << ", now @ " << timeNow << " (diffr=" << timeNow-fFLATime[channelNr] << ")" << endl;
    return fFLATime[channelNr];
  }
  else {
    // if ( eventNr == fBLAEventNr[channelNr] ) 
    //   cout << "channel " << channelNr << " in sensor " << GetStationNr() << "." << GetSensorNr() << ".B, two hits in ev " << eventNr 
    //     << " 1st @ " << fBLATime[channelNr] << ", now @ " << timeNow << " (diffr=" << timeNow-fBLATime[channelNr] << ")" << endl;
    return fBLATime[channelNr];
  }
}

void PndGemSensorMonitor::CheckNeighbours	(	Int_t	channelNr,
		Int_t	sideId,
		Int_t	eventNr,
		Int_t	digiNr,
		Double_t	channelTime,
		Double_t	channelCharge
	)

Definition at line 215 of file PndGemSensorMonitor.cxx.

References PndGemSensor::GetNeighbours().

Referenced by ActivateChannel().

                                                                                                             { // eventNr digiNr channelTime channelCharge //[R.K.03/2017] unused variable(s)
  Int_t nChan[3]={-1,-1,-1};
  Int_t nofChan = GetNeighbours(sideId,channelNr,nChan[0],nChan[1],nChan[2]);
  //  cout << "------ check " << nofChan << " neighbours of channel " << channelNr << " on sensor " << this->GetDetectorId() << "." << sideId << " : " << endl;
  for ( Int_t ichan = 0 ; ichan < nofChan ; ichan++ ) {
    //    cout << "            ---------------- channel " << nChan[ichan] << " at a distance " << GetDistance(sideId,channelNr,nChan[ichan]) << flush;
    // if ( GetDistance(sideId,channelNr,nChan[ichan]) > 1.1 || 
    //   GetDistance(sideId,channelNr,nChan[ichan]) < 0.9 ) cout << " OOOOOOOOOOOOOOOOOOOOOO" << flush;
    // cout << " // difference = " << channelNr-nChan[ichan] << flush;
    // cout << endl;
  }
  
}

PndGemSensorMonitor::ClassDef ( PndGemSensorMonitor  , 1    )

private

Int_t PndGemSensor::GetChannel ( Double_t  x, Double_t  y, Int_t  iSide  )

inherited

Calculate channel number for a coordinate pair.

Parameters

x	x coordinate in global c.s. [cm]
y	y coordinate in global c.s. [cm]
iSide	0 = front side, 1 = back side iChan channel number. -1 if point is outside sensor. Will return the same for both sides in case of pixel sensor.

Definition at line 267 of file PndGemSensor.cxx.

References Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fType, PndGemSensor::Inside(), Pi, and CAMath::Sqrt().

Referenced by PndGemFindHits::ConfirmHits(), PndGemDigitize::DigitizeEvent(), MyMainFrame::DoInfoStatusBar(), and PndGemDigitize::SimulateGaussianResponse().

                                                                  {

  if (iSide !=0 && iSide != 1) {
    cout << "-W- PndGemSensor::GetChannel: Illegal side number " 
         << iSide << endl;
    return -1;
  }

  if ( !Inside(x,y) ) return -1;
  Double_t radius = TMath::Sqrt(x*x+y*y);
  
  if ( fType == 1 ) {
    cout << "do not use this type anymore" << endl;
    return -1;
  }
  if ( fType == 0 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
       return (Int_t)(TMath::Ceil((hitPhi*fInnerRadius)/fPitch[iSide]));
    }
    if ( iSide == 1 ) {
      if ( x < 0. )
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1]));
      else
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1])) + fNChannelsBack/2;
    }
  }
  if ( fType == 2 ) { // x y strips
    if ( iSide == 0 ) { // x information encoded
//       Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));                   
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);                    
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
      if ( x <= -fInnerRadius )
        return (Int_t)((x+fOuterRadius)/fPitch[0]);
      if ( x < 0. && y >= 0. )
        return nlStrips           +(Int_t)((x+fInnerRadius)/fPitch[0]);
      if ( x < 0. && y < 0. )
        return nlStrips+  nsStrips+(Int_t)((x+fInnerRadius)/fPitch[0]);
      // now x can't be smaller than 0.
      if ( x >= fInnerRadius ) 
        return nlStrips+4*nsStrips+(Int_t)((x-fInnerRadius)/fPitch[0]);
      if ( y >= 0. )
        return nlStrips+2*nsStrips+(Int_t)((x)/fPitch[0]);
      if ( y <  0. )
        return nlStrips+3*nsStrips+(Int_t)((x)/fPitch[0]);
    }
    if ( iSide == 1 ) { // y information encoded
      if ( x <  0. ) 
        return (Int_t)((y+fOuterRadius)/fPitch[1]);
      if ( x >= 0. ) 
        return (Int_t)((y+fOuterRadius)/fPitch[1])+fNChannelsBack/2;
    }
  }
  if ( fType == 3 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      //extract radial tree factor at the OuterRadius
      Int_t ifac=1;
      //extract highest bit number
      ifac = (Int_t) (fOuterRadius / fInnerRadius);
      ifac |= (ifac >> 1);
      ifac |= (ifac >> 2);
      ifac |= (ifac >> 4);
      ifac -= (ifac >> 1);
      //extract radial tree factor at the radius
      Int_t ifac_r=1;
      ifac_r = (Int_t) ( radius / fInnerRadius);
      ifac_r |= (ifac_r >> 1);
      ifac_r |= (ifac_r >> 2);
      ifac_r |= (ifac_r >> 4);
      ifac_r -= (ifac_r >> 1);
      Int_t ich_step;
      if ( ifac_r == 0 ) return -1;
      else ich_step = (Int_t) (ifac / ifac_r);
      return (Int_t)( ich_step * TMath::Ceil(hitPhi*fNChannelsFront/ich_step/2./TMath::Pi()));
    }
    if ( iSide == 1 ) {
      if ( x < 0. )
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1]));
      else
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1])) + fNChannelsBack/2;
    }
  }
  return -1;
}

Int_t PndGemSensor::GetChannel2 ( Double_t  x, Double_t  y, Int_t  iSide, Double_t &  feeDist  )

inherited

Definition at line 824 of file PndGemSensor.cxx.

References CAMath::Abs(), CAMath::Cos(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fStripAngle, PndGemSensor::fType, PndGemSensor::Inside(), Pi, CAMath::Sqrt(), and x.

Referenced by PndGemDigitize::SimulateGaussianResponse().

                                                                                      {
  feeDist = -1.;

  if (iSide !=0 && iSide != 1) {
    cout << "-W- PndGemSensor::GetChannel: Illegal side number " 
         << iSide << endl;
    return -1;
  }

  if ( !Inside(x,y) ) return -1;
  Double_t radius = TMath::Sqrt(x*x+y*y);
  
  if ( fType == 1 ) {
    cout << "-E- !!! do not use this type anymore" << endl;
    return -1;
  }
  if ( fType == 0 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      feeDist = fOuterRadius - radius;

      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      return (Int_t)(TMath::Ceil((hitPhi*fInnerRadius)/fPitch[iSide]));
    }
    if ( iSide == 1 ) {
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      //      feeDist = hitPhi;
      if ( hitPhi < TMath::Pi()/2. )
        feeDist = hitPhi*radius;
      else if ( hitPhi < TMath::Pi() )
        feeDist = (TMath::Pi()-hitPhi)*radius;
       else if ( hitPhi < 3.*TMath::Pi()/2. )
        feeDist = (hitPhi-TMath::Pi())*radius;
       else
        feeDist = (2.*TMath::Pi()-hitPhi)*radius;
       feeDist -= fStripAngle[1]/2.; // that's the width of middle bar

      if ( x < 0. )
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1]));
      else
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1])) + fNChannelsBack/2;
    }
  }
  if ( fType == 2 ) { // x y strips
    if ( iSide == 0 ) { // x information encoded
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      Double_t feeY = TMath::Cos(hitPhi)*fOuterRadius;
      feeDist = TMath::Abs(feeY)-TMath::Abs(y);

      //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
      //Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
      if ( x <= -fInnerRadius )
        return (Int_t)((x+fOuterRadius)/fPitch[0]);
      if ( x < 0. && y >= 0. )
        return (Int_t)(nlStrips           +(x+fInnerRadius)/fPitch[0]);
      if ( x < 0. && y < 0. )
        return (Int_t)(nlStrips+  nsStrips+(x+fInnerRadius)/fPitch[0]);
      // now x can't be smaller than 0.
      if ( x >= fInnerRadius ) 
        return (Int_t)(nlStrips+4*nsStrips+(x-fInnerRadius)/fPitch[0]);
      if ( y >= 0. )
        return (Int_t)(nlStrips+2*nsStrips+(x)/fPitch[0]);
              if ( y <  0. )
        return (Int_t)(nlStrips+3*nsStrips+(x)/fPitch[0]);
    }
    if ( iSide == 1 ) { // y information encoded
      feeDist = TMath::Abs(x) - fStripAngle[1]/2.;
      
      if ( x <  0. ) 
        return (Int_t)((y+fOuterRadius)/fPitch[1]);
      if ( x >= 0. ) 
        return (Int_t)((y+fOuterRadius)/fPitch[1]+fNChannelsBack/2);
    }
  }
  if ( fType == 3 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      feeDist = fOuterRadius - radius;
      
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      //extract channel factor at the Outer radius
      Int_t ifac=1;
      ifac = (Int_t) (fOuterRadius / fInnerRadius);
      ifac |= (ifac >> 1);
      ifac |= (ifac >> 2);
      ifac |= (ifac >> 4);
      ifac -= (ifac >> 1);
      //extract channel factor at the hit radius
      Int_t ifac_r=1;
      ifac_r = (Int_t) ( radius / fInnerRadius);
      ifac_r |= (ifac_r >> 1);
      ifac_r |= (ifac_r >> 2);
      ifac_r |= (ifac_r >> 4);
      ifac_r -= (ifac_r >> 1);
      //calculate channel step at the radius
      Int_t ich_step;
      if ( ifac_r == 0 ) return -1;
      else ich_step = (Int_t) (ifac / ifac_r);
      //return channel number exists at the radius (use ceil as type0)
      return (Int_t)( ich_step *  TMath::Ceil(hitPhi*fNChannelsFront/ich_step/2./TMath::Pi()));
    }
    if ( iSide == 1 ) {
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      if ( hitPhi < TMath::Pi()/2. )
        feeDist = hitPhi*radius;
      else if ( hitPhi < TMath::Pi() )
        feeDist = (TMath::Pi()-hitPhi)*radius;
      else if ( hitPhi < 3.*TMath::Pi()/2. )
        feeDist = (hitPhi-TMath::Pi())*radius;
      else
        feeDist = (2.*TMath::Pi()-hitPhi)*radius;      
      feeDist -= fStripAngle[1]/2.; // that's the width of middle bar
      if ( x < 0. )
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1]));
      else
        return (Int_t)(TMath::Ceil((radius-fInnerRadius)/fPitch[1])) + fNChannelsBack/2;
    }
  }
  return -1.;
}

Double_t PndGemSensor::GetD ( ) const

inlineinherited

Definition at line 104 of file PndGemSensor.h.

References PndGemSensor::fD.

Referenced by PndGemFindHits::ConfirmHits2(), PndGemIdealHitProducer::Exec(), PndGemFindHits::FindHits(), and PndGemFindHits::FindHits2().

{ return fD;  }

Int_t PndGemSensor::GetDetectorId ( ) const

inlineinherited

Definition at line 89 of file PndGemSensor.h.

References PndGemSensor::fDetectorId.

Referenced by PndGemFindHits::ConfirmHits2(), PndGemDigitize::DigitizeEvent(), and PndGemDigitize::SimulateGaussianResponse().

                                            { 
    return fDetectorId; }

TString PndGemSensor::GetDetectorName ( ) const

inlineinherited

Accessors

Definition at line 86 of file PndGemSensor.h.

Referenced by PndGemFindHits::FindHits(), and PndGemFindHits::FindHits2().

{ return fName.Data(); }

Double_t PndGemSensor::GetDistance ( Int_t  iSide, Double_t  chan1, Double_t  chan2  )

inherited

Definition at line 494 of file PndGemSensor.cxx.

References CAMath::Abs(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, and PndGemSensor::fType.

Referenced by PndGemFindClustersTB::AnalyzeClusters(), PndGemFindClustersTB::CompareDigiToClusters(), and PndGemDigitize::SimulateGaussianResponse().

                                                                              {
  if ( chan1 == -1 || chan2 == -1 ){
    //cout<<"-W- !!! GetDistance(): channel number is -1 !!"<<endl;
    return -1.;
  }
  if ( iSide == 0 && ( chan1 - fNChannelsFront/2. - 1 ) * ( chan2 - fNChannelsFront/2. ) < 0. ) return -1.;
  if ( iSide == 1 && ( chan1 - fNChannelsBack /2. - 1 ) * ( chan2 - fNChannelsBack /2. ) < 0. ) return -1.;
  if ( fType == 0 ) {
    return TMath::Abs(chan1-chan2);
  }
  if ( fType == 1 ) {
    return TMath::Abs(chan1-chan2);
  }
  if ( fType == 2 ) {
    if ( iSide == 0 ) {
      //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      //Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5); //[R.K. 01/2017] unused variable?
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] +0.5);
      Int_t part1 = 666;
      Int_t part2 = 666;
      //if      ( TMath::Abs(chan1-fNChannelsFront/2) >= nsStrips*2 ) part1 =  0;
      if      ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) part1 =  0;
      //else if ( TMath::Abs(chan1-fNChannelsFront/2) <  nsStrips   ) {
      else if ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) <  nsStrips   ) {
        part1 = -1;
        if ( chan1 < fNChannelsFront/2 ) chan1 = chan1-nsStrips;
        else                             chan1 = chan1+nsStrips;
      }
      else                                                         part1 =  1;
      //if      ( TMath::Abs(chan2-fNChannelsFront/2) >= nsStrips*2 ) part2 =  0;
      if      ( TMath::Abs(chan2-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) part2 =  0;
      //else if ( TMath::Abs(chan2-fNChannelsFront/2) <  nsStrips   ) {
      else if ( TMath::Abs(chan2-fNChannelsFront/2 +0.5 ) <  nsStrips   ) {
        part2 = -1;
        if ( chan2 < fNChannelsFront/2 ) chan2 = chan2-nsStrips;
        else                             chan2 = chan2+nsStrips;
      }
      else                                                         part2 =  1;

      if ( part1*part2 == -1 ) return -1;
      return TMath::Abs(chan1-chan2);
    }
    if ( iSide == 1 ) {
      return TMath::Abs(chan1-chan2);
    }
  }
  if ( fType == 3 ) {
    if ( iSide == 0 ) {
      // radial tree 
      // it returns distance assuming the inner ring as possible minimum situation.
      Int_t ifac=1;
      Double_t retval;
      //extract channel step at the inner radius as radial tree factor
      ifac = (Int_t) (fOuterRadius / fInnerRadius);
      ifac |= (ifac >> 1);
      ifac |= (ifac >> 2);
      ifac |= (ifac >> 4);
      ifac -= (ifac >> 1); 
      retval=(Double_t) TMath::Abs( (Int_t)(chan1/ifac) - (Int_t)(chan2/ifac) );
      
      //cout << "-I- PndGemSensor::GetDistance("<<iSide<<","<<chan1<<","<<chan2<<") returns " << retval <<endl;
      
      return retval;
    }
    if ( iSide == 1 ) {
      return TMath::Abs(chan1-chan2);
    }
  }
  return -1; // ?ADDED (Stefano)
}

Int_t PndGemSensor::GetDistance ( Int_t  iSide, Int_t  chanMin, Int_t  chanMax, Int_t  chanTest  )

inherited

Definition at line 568 of file PndGemSensor.cxx.

References CAMath::Abs(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fType, and CAMath::Min().

                                                                                         {
  if ( chanMin == -1 || chanMax == -1 || chanTest ==-1 ){ 
    //cout<<"-W- !!! GetDistance(): channel number is -1 !!"<<endl;
    return -1.;
  }
  if ( iSide == 0 && ( chanMin - fNChannelsFront/2 ) * ( chanTest - fNChannelsFront/2 ) < 0. ) return -1;
  if ( iSide == 1 && ( chanMin - fNChannelsBack /2 ) * ( chanTest - fNChannelsBack /2 ) < 0. ) return -1;
  if ( fType == 0 ) {
    if ( chanTest > chanMin && chanTest < chanMax ) return 0;
    return TMath::Min(TMath::Abs(chanTest-chanMax),TMath::Abs(chanTest-chanMin));
  }
  if ( fType == 1 ) {
    if ( chanTest > chanMin && chanTest < chanMax ) return 0;
    return TMath::Min(TMath::Abs(chanTest-chanMax),TMath::Abs(chanTest-chanMin));
  }
  if ( fType == 2 ) {
    if ( iSide == 0 ) {
      //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      //Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5); //[R.K. 01/2017] unused variable?
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
      // THIS BROKEN VERTICAL STRIPS NEED SPECIAL ATTENTION
      // DO NOT YET CONSIDER ALL THE PROBLEMS...
      //if      ( TMath::Abs(chanMin-fNChannelsFront/2) < nsStrips ) {
      if      ( TMath::Abs(chanMin-fNChannelsFront/2 +0.5) < nsStrips ) {
        //      cout << "chanMin " << chanMin << " is in bad position, consider " << fNChannelsFront << "/" << nlStrips << "/" << nsStrips << flush;
        if ( chanMin < fNChannelsFront/2 ) chanMin -= nsStrips;
        else                               chanMin += nsStrips;
        //      cout << " -----> " << chanMin << " ( "  << chanMax << " , " << chanTest << " )" << endl;
      }
      //if      ( TMath::Abs(chanMax-fNChannelsFront/2) < nsStrips ) {
      if      ( TMath::Abs(chanMax-fNChannelsFront/2 +0.5) < nsStrips ) {
        //      cout << "chanMax " << chanMax << " is in bad position, consider " << fNChannelsFront << "/" << nlStrips << "/" << nsStrips << flush;
        if ( chanMax < fNChannelsFront/2 ) chanMax -= nsStrips;
        else                               chanMax += nsStrips;
        //      cout << " -----> " << chanMax << " ( "  << chanMin << " , " << chanTest << " )" << endl;
      }
      //if      ( TMath::Abs(chanTest-fNChannelsFront/2) < nsStrips ) {
      if      ( TMath::Abs(chanTest-fNChannelsFront/2 +0.5) < nsStrips ) {
        //      cout << "chanTest " << chanTest << " is in bad position, consider " << fNChannelsFront << "/" << nlStrips << "/" << nsStrips << flush;
        if ( chanTest < fNChannelsFront/2 ) chanTest -= nsStrips;
        else                                chanTest += nsStrips;
        //      cout << " -----> " << chanTest << " ( "  << chanMin << " , " << chanMax << " )" << endl;
      }
      if ( chanTest > chanMin && chanTest < chanMax ) return 0;
      return TMath::Min(TMath::Abs(chanTest-chanMax),TMath::Abs(chanTest-chanMin));
    }
    if ( iSide == 1 ) {
      if ( chanTest > chanMin && chanTest < chanMax ) return 0;
      return TMath::Min(TMath::Abs(chanTest-chanMax),TMath::Abs(chanTest-chanMin));
    }
  }
  if ( fType == 3 ) {
    if ( iSide == 0 ) {
      // radial tree 
      if ( chanTest > chanMin && chanTest < chanMax ) return 0;
      // it returns distance assuming the inner ring as possible minimum situation.
      Int_t ifac=1;
      Double_t disMin, disMax, retval;
      //extract channel step at the inner radius as radial tree factor
      ifac = (Int_t) (fOuterRadius / fInnerRadius);
      ifac |= (ifac >> 1);
      ifac |= (ifac >> 2);
      ifac |= (ifac >> 4);
      ifac -= (ifac >> 1); 
      disMin=(Double_t) TMath::Abs( (Int_t)(chanTest/ifac) - (Int_t)(chanMin/ifac) );
      disMax=(Double_t) TMath::Abs( (Int_t)(chanTest/ifac) - (Int_t)(chanMax/ifac) );
      retval = TMath::Min(disMin,disMax);
      //cout << "-I- PndGemSensor::GetDistance("<<iSide<<","<<chanMin<<","<<chanMax<<","<<chanTest<<") returns " << retval <<endl;
      
      return retval;
    }
    if ( iSide == 1 ) {
      if ( chanTest > chanMin && chanTest < chanMax ) return 0;
      return TMath::Min(TMath::Abs(chanTest-chanMax),TMath::Abs(chanTest-chanMin));
    }
  }
  return -1; // ? ADDED (Stefano)
}

Double_t PndGemSensor::GetDistance2 ( Int_t  iSide, Double_t  chan1, Double_t  chan2  )

inherited

Definition at line 653 of file PndGemSensor.cxx.

References CAMath::Abs(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, and PndGemSensor::fType.

Referenced by PndGemFindClusters::CompareDigiToClustersDigis().

                                                                               {
  if ( chan1 == -1 || chan2 == -1 ) return -1.;
  if ( iSide == 0 && ( chan1 - fNChannelsFront/2. ) * ( chan2 - fNChannelsFront/2. ) < 0. ) return -1.;
  if ( iSide == 1 && ( chan1 - fNChannelsBack /2. ) * ( chan2 - fNChannelsBack /2. ) < 0. ) return -1.;
  if ( fType == 0 ) {
    return TMath::Abs(chan1-chan2);
  }
  if ( fType == 1 ) {
    return TMath::Abs(chan1-chan2);
  }
  if ( fType == 2 ) {
    if ( iSide == 0 ) {
//       Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      //Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5); //[R.K. 01/2017] unused variable?
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
      Int_t part1 = 666;
      Int_t part2 = 666;
      //if      ( TMath::Abs(chan1-fNChannelsFront/2) > nsStrips*2 ) part1 =  0;
      if      ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) part1 =  0;
      //else if ( TMath::Abs(chan1-fNChannelsFront/2) < nsStrips   ) {
      else if ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) < nsStrips   ) {
        part1 = -1;
        if ( chan1 < fNChannelsFront/2 ) chan1 = chan1-nsStrips;
        else                             chan1 = chan1+nsStrips;
      }
      else                                                         part1 =  1;
      //if      ( TMath::Abs(chan2-fNChannelsFront/2) > nsStrips*2 ) part2 =  0;
      if      ( TMath::Abs(chan2-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) part2 =  0;
      //else if ( TMath::Abs(chan2-fNChannelsFront/2) < nsStrips   ) {
      else if ( TMath::Abs(chan2-fNChannelsFront/2 +0.5) < nsStrips   ) {
        part2 = -1;
        if ( chan2 < fNChannelsFront/2 ) chan2 = chan2-nsStrips;
        else                             chan2 = chan2+nsStrips;
      }
      else                                                         part2 =  1;
      
      if ( part1*part2 == -1 ) return -1;
      return TMath::Abs(chan1-chan2);
    }
    if ( iSide == 1 ) {
      return TMath::Abs(chan1-chan2);
    }
  }
  // radial tree
  if ( fType == 3 ) {
    if ( iSide == 0 ) {
      Int_t ifac=1,ifac_test=1, ifac1=1, ifac2=1,icom_ifac=0;
      Int_t ideno,iring_test=0,iring1=0,iring2=0; //,icom_ring=0; //[R.K. 01/2017] unused variable?
      Int_t itest1,itest2,i1ok=0,i2ok=0;
      Int_t icom_chstep=0;
      Double_t retval;
      //extract the radial tree factor of outer radius
      ifac = (Int_t) (fOuterRadius / fInnerRadius);
      ifac |= (ifac >> 1);
      ifac |= (ifac >> 2);
      ifac |= (ifac >> 4);
      ifac -= (ifac >> 1); 
      //find minimum ring for ch1 and ch2 
      itest1=(Int_t)chan1;
      itest2=(Int_t)chan2;
      for( ideno=ifac; ideno>=1; ideno/=2){
        iring_test++;
        //cout << "ideno="<< ideno <<" iring_test="<<iring_test<<" ifac_test="<<ifac_test<<endl;
        itest1%=ideno;
        if( itest1 == 0 && i1ok == 0){
          //cout <<"Minimum ring of ch1 found at #"<<iring_test<<endl;
          iring1=iring_test;
          ifac1=ifac_test;
          i1ok=1;
        }
        itest2%=ideno;
        if( itest2 == 0 && i2ok == 0){
          //cout <<"Minimum ring of ch2 found at #"<<iring_test<<endl;
          iring2=iring_test;
          ifac2=ifac_test;
          i2ok=1;
        }
        ifac_test*=2;
      }
      //take minimum common ring
      if( iring1 >= iring2 ){
        //icom_ring=iring1; //[R.K. 01/2017] unused variable?
        icom_ifac=ifac1;
      }
      else{
        //icom_ring=iring2; //[R.K. 01/2017] unused variable?
        icom_ifac=ifac2;
      }
      //channel step at the common ring
      if(ifac%icom_ifac == 0){
        icom_chstep=ifac/icom_ifac;
      }
      else{
        cout<<"-W- !!! something wrong on ifac..in PndGemSensor::GetDistance2() !!!"<<endl;
      }
      retval = TMath::Abs(chan1-chan2)/(Double_t)icom_chstep;

      //cout << "-I- PndGemSensor::GetDistance2("<<iSide<<","<<chan1<<","<<chan2<<") returns "<< retval <<" for Common ring #"<<icom_ring<<" ifac="<<icom_ifac<<" ch_step="<<icom_chstep<<endl;
      
      return retval; 
    }
    if ( iSide == 1 ) {
      return TMath::Abs(chan1-chan2);
    }
  }
  return -1; // ? ADDED (Stefano)
}

Double_t PndGemSensor::GetInnerRadius ( ) const

inlineinherited

Definition at line 102 of file PndGemSensor.h.

References PndGemSensor::fInnerRadius.

Referenced by MyMainFrame::DrawDigis(), and PndGemIdealHitProducer::Exec().

{ return fInnerRadius; }

Double_t PndGemSensor::GetMeanChannel ( Int_t  iSide, Double_t  chan1, Double_t  weight1, Double_t  chan2, Double_t  weight2  )

inherited

Definition at line 764 of file PndGemSensor.cxx.

References CAMath::Abs(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, and PndGemSensor::fType.

Referenced by PndGemFindClustersTB::AddDigiToCluster(), and PndGemFindClusters::AddDigiToCluster().

                                                                                                                     {
  if ( chan1 == -1 || chan2 == -1 ) return -1.;
  if ( iSide == 0 && ( chan1 - fNChannelsFront/2. ) * ( chan2 - fNChannelsFront/2. ) < 0. ) return -1.;
  if ( iSide == 1 && ( chan1 - fNChannelsBack /2. ) * ( chan2 - fNChannelsBack /2. ) < 0. ) return -1.;
  if ( fType == 0 ) {
    return (chan1*weight1+chan2*weight2)/(weight1+weight2);
  }
  if ( fType == 1 ) {
    return (chan1*weight1+chan2*weight2)/(weight1+weight2);
  }
  if ( fType == 2 ) {
    if ( iSide == 0 ) {
      //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
      Int_t part1 = 666;
      Int_t part2 = 666;
      //if      ( TMath::Abs(chan1-fNChannelsFront/2) >= nsStrips*2 ) part1 =  0;
      if      ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) part1 =  0;
      //else if ( TMath::Abs(chan1-fNChannelsFront/2) <  nsStrips   ) {
      else if ( TMath::Abs(chan1-fNChannelsFront/2 +0.5 ) <  nsStrips   ) {
        part1 = -1;
        if ( chan1 < fNChannelsFront/2 ) chan1 = chan1-nsStrips;
        else                             chan1 = chan1+nsStrips;
      }
      else                                                          part1 =  1;
      //if      ( TMath::Abs(chan2-fNChannelsFront/2) >= nsStrips*2 ) part2 =  0;
      if      ( TMath::Abs(chan2-fNChannelsFront/2 +0.5) > nsStrips*2 ) part2 =  0;
      //else if ( TMath::Abs(chan2-fNChannelsFront/2) <  nsStrips   ) {
      else if ( TMath::Abs(chan2-fNChannelsFront/2 +0.5) <  nsStrips   ) {
        part2 = -1;
        if ( chan2 < fNChannelsFront/2 ) chan2 = chan2-nsStrips;
        else                             chan2 = chan2+nsStrips;
      }
      else                                                         part2 =  1;

      if ( part1*part2 == -1 ) return -1;

      Double_t meanCh = (chan1*weight1+chan2*weight2)/(weight1+weight2);

      if ( part1+part2 < 0 ) {
        if ( meanCh > nlStrips && meanCh < nlStrips+nsStrips ) meanCh += nsStrips;
        if ( meanCh > fNChannelsFront/2+nsStrips && meanCh < fNChannelsFront-nlStrips ) meanCh -= nsStrips;
      }

      return meanCh;
    }
    if ( iSide == 1 ) {
      return (chan1*weight1+chan2*weight2)/(weight1+weight2);
    }
  }
  if ( fType == 3 ) {
    return (chan1*weight1+chan2*weight2)/(weight1+weight2);
  }
  return -1; // ? ADDED (Stefano)
}

Int_t PndGemSensor::GetNChannels ( ) const

inlineinherited

Definition at line 110 of file PndGemSensor.h.

References PndGemSensor::fNChannelsBack, and PndGemSensor::fNChannelsFront.

Referenced by PndGemDigiPar::CreateStations(), and PndGemStation::GetNChannels().

{ return fNChannelsFront+fNChannelsBack; }

Int_t PndGemSensor::GetNChannelsBack ( ) const

inlineinherited

Definition at line 112 of file PndGemSensor.h.

References PndGemSensor::fNChannelsBack.

Referenced by MyMainFrame::DrawDigis(), and PndGemSensorMonitor().

{ return fNChannelsBack;  }

Int_t PndGemSensor::GetNChannelsFront ( ) const

inlineinherited

Definition at line 111 of file PndGemSensor.h.

References PndGemSensor::fNChannelsFront.

Referenced by MyMainFrame::DrawDigis(), and PndGemSensorMonitor().

{ return fNChannelsFront; }

Int_t PndGemSensor::GetNeighbours ( Int_t  iSide, Int_t  iChan, Int_t &  nChan1, Int_t &  nChan2, Int_t &  nChan3  )

inherited

Definition at line 362 of file PndGemSensor.cxx.

References PndGemSensor::fType.

Referenced by CheckNeighbours().

                                                                                                       {
  nChan1=-1;
  nChan2=-1;
  nChan3=-1;
  if ( fType == 0 ) {
    nChan1 = iChan-1;
    nChan2 = iChan+1;
    return 2;
  }
  if ( fType == 1 ) {
    nChan1 = iChan-1;
    nChan2 = iChan+1;
    return 2;
  }
  if ( fType == 2 ) {
    if ( iSide == 1 ) {
      nChan1 = iChan-1;
      nChan2 = iChan+1;
      return 2;
    }
    if ( iSide == 0 ) {
      nChan1 = iChan-1;
      nChan2 = iChan+1;
      return 2;
    }
  }
  if ( fType == 3 ) {
    if ( iSide == 0 ) {// radial tree
      // need to decide what to return...(?)
      nChan1 = iChan-1;
      nChan2 = iChan+1;
      return 2;
    }
    if ( iSide == 1 ) {
      nChan1 = iChan-1;
      nChan2 = iChan+1;
    }
  }
  return 0;
}

Double_t PndGemSensor::GetOuterRadius ( ) const

inlineinherited

Definition at line 103 of file PndGemSensor.h.

References PndGemSensor::fOuterRadius.

Referenced by PndGemFindHitsAna::CreateHistos(), PndGemFindHitsQA::CreateHistos(), MyMainFrame::DrawDigis(), PndGemIdealHitProducer::Exec(), PndGemFindHits::FindHits(), PndGemFindHits::FindHits2(), PndGemFindClusters::Init(), PndGemFindHits::Init(), PndGemFindClustersTB::Init(), PndSttMvdGemTracking::PropagateToGemPlaneAsHelix(), and PndSttMvdGemTracking::Reset().

{ return fOuterRadius; }

Double_t PndGemSensor::GetPitch ( Int_t  index ) const

inlineinherited

Definition at line 106 of file PndGemSensor.h.

References PndGemSensor::fPitch.

Referenced by MyMainFrame::DrawDigis(), and PndGemIdealHitProducer::Exec().

{ return fPitch[index]; }

Double_t PndGemSensor::GetRotation ( ) const

inlineinherited

Definition at line 101 of file PndGemSensor.h.

References PndGemSensor::fRotation.

{ return fRotation; }

Int_t PndGemSensor::GetSensorNr ( ) const

inlineinherited

Definition at line 95 of file PndGemSensor.h.

References PndGemSensor::fDetectorId.

Referenced by PndGemStation::AddSensor(), PndGemMonitor::CreateSensorMonitor(), PndGemFindHits::Exec(), PndGemFindHits::FindHits(), PndGemFindHits::FindHits2(), and PndGemSensor::Print().

                                 {  // sensor number within station
    return ( ( fDetectorId & (   3<< 6) ) >>  6 ); }

Int_t PndGemSensor::GetSensorPart ( Int_t  iSide, Int_t  chan  )

inherited

Definition at line 405 of file PndGemSensor.cxx.

References CAMath::Abs(), PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsFront, PndGemSensor::fPitch, and PndGemSensor::fType.

Referenced by PndGemFindClustersTB::CheckCluster().

                                                         {
  if ( fType == 0 ) {
    return -1;
  }
  if ( fType == 1 ) {
    return -1;
  }
  if ( fType == 2 ) {
    if ( iSide == 1 ) {
      return -1;
    }
    if ( iSide == 0 ) {
//       Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
      Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0]+0.5);
      //if      ( TMath::Abs(chan-fNChannelsFront/2) > nsStrips*2 ) 
      if      ( TMath::Abs(chan-fNChannelsFront/2 +0.5 ) > nsStrips*2 ) 
        return 0;
      //else if ( TMath::Abs(chan-fNChannelsFront/2) < nsStrips   )
      else if ( TMath::Abs(chan-fNChannelsFront/2 +0.5) < nsStrips   )
        return 2;
      else 
        return 1;
    }
  }
  if ( fType == 3 ) {
    //should it be irregular??
    return -1;
  }
  return -1;
}

Int_t PndGemSensor::GetSideChannels ( Int_t  si ) const

inlineinherited

Definition at line 114 of file PndGemSensor.h.

References PndGemSensor::fNChannelsBack, and PndGemSensor::fNChannelsFront.

Referenced by PndGemDigiAna::CreateHistos().

{ if ( si==0 ) return fNChannelsFront; return fNChannelsBack;} // will return NChFront for si==0, and NChBack for anything else

Double_t PndGemSensor::GetSigmaX ( ) const

inlineinherited

Definition at line 107 of file PndGemSensor.h.

References PndGemSensor::fSigmaX.

{ return fSigmaX; }

Double_t PndGemSensor::GetSigmaXY ( ) const

inlineinherited

Definition at line 109 of file PndGemSensor.h.

References PndGemSensor::fSigmaXY.

{ return fSigmaXY; }

Double_t PndGemSensor::GetSigmaY ( ) const

inlineinherited

Definition at line 108 of file PndGemSensor.h.

References PndGemSensor::fSigmaY.

{ return fSigmaY; }

Int_t PndGemSensor::GetStationNr ( ) const

inlineinherited

Definition at line 93 of file PndGemSensor.h.

References PndGemSensor::fDetectorId.

Referenced by PndGemMonitor::CreateSensorMonitor(), PndGemFindHits::FindHits(), and PndGemFindHits::FindHits2().

                                 { 
    return ( ( fDetectorId & (8191<< 8) ) >>  8 ); }

Double_t PndGemSensor::GetStripAngle ( Int_t  index ) const

inlineinherited

Definition at line 105 of file PndGemSensor.h.

References PndGemSensor::fStripAngle.

Referenced by MyMainFrame::DrawDigis(), and PndGemIdealHitProducer::Exec().

{ return fStripAngle[index]; }

Double_t PndGemSensor::GetStripOrientation ( Double_t  x, Double_t  y, Int_t  iSide  )

inherited

Activate the channels corresponding to a MCPoint.

Parameters

ipt	Index of MCPoint
x	x coordinate of point (global c.s.)
y	y coordinate of point (global c.s.) kTRUE if the point is inside the sensor, else kFALSE

Definition at line 438 of file PndGemSensor.cxx.

References Double_t, PndGemSensor::fType, PndGemSensor::Inside(), Pi, and CAMath::Sqrt().

Referenced by PndGemDigitize::SimulateGaussianResponse().

                                                                              {
  if (iSide !=0 && iSide != 1) return -1.;
  if ( !Inside(x,y) ) return -1.;

  if ( fType == 1 ) {
    return -1.;
  }
  if ( fType == 0 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      Double_t radius = TMath::Sqrt(x*x+y*y);
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      return hitPhi;
    }
    if ( iSide == 1 ) {
      Double_t radius = TMath::Sqrt(x*x+y*y);
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      return hitPhi+TMath::Pi()/2.;
    }
  }
  if ( fType == 2 ) { // x y strips
    if ( iSide == 0 ) { // x information encoded
      return 0.;
    }
    if ( iSide == 1 ) { // y information encoded
      return TMath::Pi()/2.;
    }
  }
  if ( fType == 3 ) { // angle info for iSide 0, radius info for iSide 1
    if ( iSide == 0 ) {
      Double_t radius = TMath::Sqrt(x*x+y*y);
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      return hitPhi;
    }
    if ( iSide == 1 ) {
      Double_t radius = TMath::Sqrt(x*x+y*y);
      Double_t hitPhi = TMath::ACos(y/radius);
      if ( x < 0. ) 
        hitPhi = 2.*TMath::Pi()-hitPhi;
      hitPhi = 2.*TMath::Pi()-hitPhi;
      return hitPhi+TMath::Pi()/2.;
    }
  }
  return -1.;
}

Int_t PndGemSensor::GetSystemId ( ) const

inlineinherited

Definition at line 91 of file PndGemSensor.h.

References PndGemSensor::fDetectorId.

                                 { 
    return ( ( fDetectorId & (  31<<27) ) >> 27); }

Int_t PndGemSensor::GetType ( ) const

inlineinherited

Definition at line 97 of file PndGemSensor.h.

References PndGemSensor::fType.

{ return fType; }

Double_t PndGemSensor::GetX0 ( ) const

inlineinherited

Definition at line 98 of file PndGemSensor.h.

References PndGemSensor::fPosition.

Referenced by PndSttMvdGemTracking::SetupGEMPlanes().

{ return fPosition[0]; }

Double_t PndGemSensor::GetY0 ( ) const

inlineinherited

Definition at line 99 of file PndGemSensor.h.

References PndGemSensor::fPosition.

Referenced by PndSttMvdGemTracking::SetupGEMPlanes().

{ return fPosition[1]; }

Double_t PndGemSensor::GetZ0 ( ) const

inlineinherited

Definition at line 100 of file PndGemSensor.h.

References PndGemSensor::fPosition.

Referenced by PndGemFindHits::ConfirmHits(), PndGemFindHitsAna::CreateHistos(), PndGemFindHitsQA::CreateHistos(), PndSttMvdGemTracking::Exec(), PndGemIdealHitProducer::Exec(), PndGemStation::GetNofZ(), PndGemStation::GetZ(), and PndSttMvdGemTracking::SetupGEMPlanes().

{ return fPosition[2]; }

Bool_t PndGemSensor::Inside ( Double_t  x, Double_t  y  )

inherited

Test whether a coordinate pair (x,y) in global coordinates is inside the sensor

Definition at line 1027 of file PndGemSensor.cxx.

References CAMath::Abs(), Double_t, PndGemSensor::fInnerRadius, PndGemSensor::fOuterRadius, PndGemSensor::fStripAngle, and y.

Referenced by PndGemSensor::GetChannel(), PndGemSensor::GetChannel2(), PndGemSensor::GetStripOrientation(), and PndGemSensor::Intersect().

                                                  {
  if ( TMath::Abs(x) < fStripAngle[1]/2. ) return kFALSE;
  Double_t radSq = x*x+y*y;
  if ( radSq < fInnerRadius*fInnerRadius ) return kFALSE;
  if ( radSq > fOuterRadius*fOuterRadius ) return kFALSE;
  return kTRUE;
}

Bool_t PndGemSensor::Inside ( Double_t  radius )

inherited

Definition at line 1037 of file PndGemSensor.cxx.

References PndGemSensor::fInnerRadius, and PndGemSensor::fOuterRadius.

                                           {
  if ( radius < fInnerRadius ) return kFALSE;
  if ( radius > fOuterRadius ) return kFALSE;
  return kTRUE;
}

Int_t PndGemSensor::Intersect ( Double_t  iFStrip, Double_t  iBStrip, Double_t &  xCross, Double_t &  yCross, Double_t &  zCross  )

inherited

Calculates the coordinates of the intersections of front strip i with back strip j in the global coordinate system

Parameters

iFStrip	Front strip number
iBStrip	Back strip number
xCross	Vector of x coordinates of crossings [cm]
yCross	Vector of y coordinates of crossings [cm] Number of intersections

Definition at line 1045 of file PndGemSensor.cxx.

References CAMath::Cos(), Double_t, PndGemSensor::fDetectorId, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fPosition, PndGemSensor::fType, PndGemSensor::Inside(), phi, Pi, and CAMath::Sin().

Referenced by PndGemFindHits::FindHits(), and PndGemFindHits::FindHits2().

                                                                                                                      {
  //  cout << "trying to find intersection of strip " << iFStrip << " and " << iBStrip << endl;

  if ( fType == -1 ) {
    cout << "-E- !!! not supported anymore" << endl;
    return -1;
  }
  // the hits are on different sides
  if ( iFStrip <  fNChannelsFront/2 && iBStrip >= fNChannelsBack/2 ) return -1;
  if ( iFStrip >= fNChannelsFront/2 && iBStrip <  fNChannelsBack/2 ) return -1;
  
  Double_t bs = iBStrip;
  if ( bs >= fNChannelsBack/2 ) bs -= fNChannelsBack/2;
  if ( fType == 0 ) { // r phi strips
    Double_t phi    = fPitch[0]*((Double_t)iFStrip-0.5) / fInnerRadius;
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];
    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  if ( fType == 2 ) { // x y strips
    //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
    //Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
    Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);
    Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
    //Double_t x = -666.; //[R.K. 01/2017] unused variable?
    yCross = -fOuterRadius+(Double_t(bs)+0.5)*fPitch[1];
    zCross = fPosition[2];
    if ( iFStrip < nlStrips ) {
      xCross = -fOuterRadius+(Double_t(iFStrip)+0.5)*fPitch[0];
      if ( !Inside(xCross,yCross) ) return -1;
      return fDetectorId;
    }
    if ( iFStrip < nlStrips+  nsStrips ) {
      if ( bs <  fNChannelsBack/4 ) return -1;
      xCross = -fOuterRadius+(Double_t(iFStrip)+0.5)*fPitch[0];
      if ( !Inside(xCross,yCross) ) return -1;
      return fDetectorId;
    }
    if ( iFStrip < nlStrips+2*nsStrips ) {
      if ( bs >= fNChannelsBack/4 ) return -1;
      xCross = -fOuterRadius+(Double_t(iFStrip-nsStrips)+0.5)*fPitch[0];
      if ( !Inside(xCross,yCross) ) return -1;
      return fDetectorId;
    }
    if ( iFStrip < nlStrips+3*nsStrips ) {
      if ( bs <  fNChannelsBack/4 ) return -1;
      xCross = -fOuterRadius+(Double_t(iFStrip-nsStrips)+0.5)*fPitch[0];
      if ( !Inside(xCross,yCross) ) return -1;
      return fDetectorId;
    }
    if ( iFStrip < nlStrips+4*nsStrips ) {
      if ( bs >= fNChannelsBack/4 ) return -1;
      xCross = -fOuterRadius+(Double_t(iFStrip-3*nsStrips)+0.5)*fPitch[0];
      if ( !Inside(xCross,yCross) ) return -1;
      return fDetectorId;
    }
  }
  if ( fType == 3 ) { 
    Double_t phi    = 2. * TMath::Pi() * ((Double_t)iFStrip-0.5) / (Double_t)fNChannelsFront;
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];
    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  return -1;
}

Int_t PndGemSensor::Intersect ( Double_t  iFStrip, Double_t  iBStrip, Double_t &  xCross, Double_t &  yCross, Double_t &  zCross, Double_t &  dr, Double_t &  dp  )

inherited

Definition at line 1124 of file PndGemSensor.cxx.

References CAMath::Cos(), Double_t, PndGemSensor::fDetectorId, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fPosition, PndGemSensor::fType, PndGemSensor::Inside(), phi, Pi, CAMath::Sin(), and CAMath::Sqrt().

                                                          {
  //  cout << "trying to find intersection of strip " << iFStrip << " and " << iBStrip << endl;

  if ( fType == -1 ) {
    cout << "-E- !!! not supported anymore" << endl;
    return -1;
  }
  // the hits are on different sides
  //cout << iFStrip << " of " << fNChannelsFront << " and " << iBStrip << " of " << fNChannelsBack << endl;
  if ( iFStrip <  fNChannelsFront/2 && iBStrip >= fNChannelsBack/2 ) return -1;
  if ( iFStrip >= fNChannelsFront/2 && iBStrip <  fNChannelsBack/2 ) return -1;
  Double_t bs = iBStrip;
  if ( bs >= fNChannelsBack/2 ) bs -= fNChannelsBack/2;
  if ( fType == 0 ) { // r phi strips
    Double_t phi    = fPitch[0]*((Double_t)iFStrip-0.5) / fInnerRadius;
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];

    dp = fPitch[0]*radius/fInnerRadius/TMath::Sqrt(12.);
    dr = fPitch[1]/TMath::Sqrt(12.);

    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  if ( fType == 2 ) { // x y strips
    //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
//     Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
    Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);
    Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
    //Double_t x = -666.; //[R.K. 01/2017] unused variable?
    yCross = -fOuterRadius+(Double_t(bs)+0.5)*fPitch[1];
    zCross = fPosition[2];

    if      ( iFStrip < nlStrips )
       xCross = -fOuterRadius+(Double_t(iFStrip)+0.5)*fPitch[0];
     else if ( iFStrip < nlStrips+  nsStrips ) {
       if ( bs <  fNChannelsBack/4 ) return -1;
       xCross = (Double_t(iFStrip-nlStrips-1*nsStrips)+0.5)*fPitch[0];
     }
     else if ( iFStrip < nlStrips+2*nsStrips ) {
       if ( bs >= fNChannelsBack/4 ) return -1;
       xCross = (Double_t(iFStrip-nlStrips-2*nsStrips)+0.5)*fPitch[0];
     }
     else if ( iFStrip < nlStrips+3*nsStrips ) {
       if ( bs <  fNChannelsBack/4 ) return -1;
       xCross = (Double_t(iFStrip-nlStrips-2*nsStrips)+0.5)*fPitch[0];
     }
     else if ( iFStrip < nlStrips+4*nsStrips ) {
       if ( bs >= fNChannelsBack/4 ) return -1;
       xCross = (Double_t(iFStrip-nlStrips-3*nsStrips)+0.5)*fPitch[0];
     }
     else
       xCross = (Double_t(iFStrip-nlStrips-3*nsStrips)+0.5)*fPitch[0];
    
    if ( !Inside(xCross,yCross) ) return -1;

    /*
      Double_t rMax = TMath::Sqrt( (TMath::Abs(xCross)+fPitch[0])*(TMath::Abs(xCross)+fPitch[0])+
      (TMath::Abs(yCross)+fPitch[1])*(TMath::Abs(yCross)+fPitch[1]) );
      Double_t rMin = TMath::Sqrt( (TMath::Abs(xCross)-fPitch[0])*(TMath::Abs(xCross)-fPitch[0])+
      (TMath::Abs(yCross)-fPitch[1])*(TMath::Abs(yCross)-fPitch[1]) );
`      Double_t phi1 = TMath::ATan( (TMath::Abs(yCross)-fPitch[1])/(TMath::Abs(xCross)+fPitch[0]) );
      Double_t phi2 = TMath::ATan( (TMath::Abs(yCross)+fPitch[1])/(TMath::Abs(xCross)-fPitch[0]) );
      dp = TMath::Abs(phi1-phi2);
      dp = TMath::Tan(dp)*(rMax+rMin)/2./TMath::Sqrt(12.);
      dr = (rMax-rMin)/TMath::Sqrt(12.);
      //     if ( dp > 350 ) 
      //       dp = TMath::Abs(360.-dp);
      */
    dr = fPitch[0]/TMath::Sqrt(12.);
    dp = fPitch[1]/TMath::Sqrt(12.);

    return fDetectorId;
  }
  if ( fType == 3 ) { // r_a phi strips
    Double_t phi    = 2. * TMath::Pi() * ((Double_t)iFStrip-0.5) / (Double_t)fNChannelsFront;
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];
    //extract channel factor at the hit radius
    Int_t ifac_r=1;
    ifac_r = (Int_t) ( radius / fInnerRadius);
    ifac_r |= (ifac_r >> 1);
    ifac_r |= (ifac_r >> 2);
    ifac_r |= (ifac_r >> 4);
    ifac_r -= (ifac_r >> 1);
    dp = fPitch[0]*radius/fInnerRadius/ifac_r/TMath::Sqrt(12.);
    dr = fPitch[1]/TMath::Sqrt(12.);
    
    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  
  return -1;
}

Int_t PndGemSensor::Intersect ( Double_t  iFStrip, Double_t  iBStrip, Double_t &  xCross, Double_t &  yCross, Double_t &  zCross, Double_t &  dx, Double_t &  dy, Double_t &  dr, Double_t &  dp  )

inherited

Definition at line 1230 of file PndGemSensor.cxx.

References CAMath::Abs(), CAMath::Cos(), Double_t, PndGemSensor::fDetectorId, PndGemSensor::fInnerRadius, PndGemSensor::fNChannelsBack, PndGemSensor::fNChannelsFront, PndGemSensor::fOuterRadius, PndGemSensor::fPitch, PndGemSensor::fPosition, PndGemSensor::fType, PndGemSensor::Inside(), phi, Pi, CAMath::Sin(), and CAMath::Sqrt().

                                                                                      {
  //  cout << "trying to find intersection of strip " << iFStrip << " and " << iBStrip << endl;
  if ( fType == -1 ) {
    cout << "-E- !!! not supported anymore" << endl;
    return -1;
  }
  // the hits are on different sides
  //cout << iFStrip << " of " << fNChannelsFront << " and " << iBStrip << " of " << fNChannelsBack << endl;
  if ( iFStrip <  fNChannelsFront/2 && iBStrip >= fNChannelsBack/2 ) return -1;
  if ( iFStrip >= fNChannelsFront/2 && iBStrip <  fNChannelsBack/2 ) return -1;
  Double_t bs = iBStrip;
  if ( bs >= fNChannelsBack/2 ) bs -= fNChannelsBack/2;
  if ( fType == 0 ) { // r phi strips
    Double_t phi    = fPitch[0]*((Double_t)iFStrip-0.5) / fInnerRadius; // the angle is counted from Y axis
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];

    dp = fPitch[0]*radius/fInnerRadius/TMath::Sqrt(12.);
    dr = fPitch[1]/TMath::Sqrt(12.);
    dx = dr*TMath::Abs(TMath::Sin(phi))+dp*TMath::Abs(TMath::Cos(phi));
    dy = dr*TMath::Abs(TMath::Cos(phi))+dp*TMath::Abs(TMath::Sin(phi));

    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  if ( fType == 2 ) { // x y strips
    //Int_t nlStrips = (Int_t)(TMath::Ceil((fOuterRadius-fInnerRadius)/fPitch[0]));
    //Int_t nsStrips = (Int_t)(TMath::Ceil(fInnerRadius/fPitch[0]));
    Int_t nlStrips = (Int_t)((fOuterRadius-fInnerRadius)/fPitch[0] + 0.5);
    Int_t nsStrips = (Int_t)(fInnerRadius/fPitch[0] + 0.5);
    //cout << " nlStrips="<<nlStrips<<" nsStrips="<<nsStrips<<endl;
    //Double_t x = -666.; //[R.K. 01/2017] unused variable?
    yCross = -fOuterRadius+(Double_t(bs)+0.5)*fPitch[1];
    zCross = fPosition[2];
    
    if      ( iFStrip < nlStrips )
        xCross = -fOuterRadius+(Double_t(iFStrip)+0.5)*fPitch[0];
    else if ( iFStrip < nlStrips+  nsStrips ) {
        if ( bs <  fNChannelsBack/4 ) return -1;
        xCross = (Double_t(iFStrip-nlStrips-1*nsStrips)+0.5)*fPitch[0];
    }
    else if ( iFStrip < nlStrips+2*nsStrips ) {
        if ( bs >= fNChannelsBack/4 ) return -1;
        xCross = (Double_t(iFStrip-nlStrips-2*nsStrips)+0.5)*fPitch[0];
    }
    else if ( iFStrip < nlStrips+3*nsStrips ) {
        if ( bs <  fNChannelsBack/4 ) return -1;
        xCross = (Double_t(iFStrip-nlStrips-2*nsStrips)+0.5)*fPitch[0];
    }
    else if ( iFStrip < nlStrips+4*nsStrips ) {
        if ( bs >= fNChannelsBack/4 ) return -1;
        xCross = (Double_t(iFStrip-nlStrips-3*nsStrips)+0.5)*fPitch[0];
    }
    else
        xCross = (Double_t(iFStrip-nlStrips-3*nsStrips)+0.5)*fPitch[0];
    
 
    if ( !Inside(xCross,yCross) ) return -1;

    /*
      Double_t rMax = TMath::Sqrt( (TMath::Abs(xCross)+fPitch[0])*(TMath::Abs(xCross)+fPitch[0])+
      (TMath::Abs(yCross)+fPitch[1])*(TMath::Abs(yCross)+fPitch[1]) );
      Double_t rMin = TMath::Sqrt( (TMath::Abs(xCross)-fPitch[0])*(TMath::Abs(xCross)-fPitch[0])+
      (TMath::Abs(yCross)-fPitch[1])*(TMath::Abs(yCross)-fPitch[1]) );
`      Double_t phi1 = TMath::ATan( (TMath::Abs(yCross)-fPitch[1])/(TMath::Abs(xCross)+fPitch[0]) );
      Double_t phi2 = TMath::ATan( (TMath::Abs(yCross)+fPitch[1])/(TMath::Abs(xCross)-fPitch[0]) );
      dp = TMath::Abs(phi1-phi2);
      dp = TMath::Tan(dp)*(rMax+rMin)/2./TMath::Sqrt(12.);
      dr = (rMax-rMin)/TMath::Sqrt(12.);
      //     if ( dp > 350 ) 
      //       dp = TMath::Abs(360.-dp);
      */
    dx = fPitch[0]/TMath::Sqrt(12.);
    dy = fPitch[1]/TMath::Sqrt(12.);
    dr = 0.;
    dp = 0.;

    return fDetectorId;
  }
  if ( fType == 3 ) { // r_a phi strips
    Double_t radius = fPitch[1]*((Double_t) bs    -0.5) + fInnerRadius;
    //extract channel factor at the Outer radius
    Int_t ifac=1;
    ifac = (Int_t) (fOuterRadius / fInnerRadius);
    ifac |= (ifac >> 1);
    ifac |= (ifac >> 2);
    ifac |= (ifac >> 4);
    ifac -= (ifac >> 1);
    //extract channel factor at the hit radius
    Int_t ifac_r=1;
    ifac_r = (Int_t) ( radius / fInnerRadius);
    if ( ifac_r == 0 ) {
      cout<<"-W- PndGemSensor::Intersect() radius (" << radius << ") in smaller than InnerRadius (" << fInnerRadius << ").. return -1! (strip " << iFStrip << " / " << iBStrip << " )" <<endl;
      return -1;
    }
    ifac_r |= (ifac_r >> 1);
    ifac_r |= (ifac_r >> 2);
    ifac_r |= (ifac_r >> 4);
    ifac_r -= (ifac_r >> 1);
    //calculate channel step at the radius
    Int_t ich_step;
    if ( ifac_r == 0 ) return -1;
    else ich_step = (Int_t) (ifac / ifac_r);
    Double_t phi    = 2. * TMath::Pi() * ((Double_t)iFStrip-0.5*(Double_t)ich_step) / (Double_t)fNChannelsFront;
    yCross =  radius*TMath::Cos(phi);
    xCross = -radius*TMath::Sin(phi);
    zCross = fPosition[2];
    dp = fPitch[0]*radius/fInnerRadius/ifac_r/TMath::Sqrt(12.);
    dr = fPitch[1]/TMath::Sqrt(12.);
    dx = dr*TMath::Abs(TMath::Sin(phi))+dp*TMath::Abs(TMath::Cos(phi));
    dy = dr*TMath::Abs(TMath::Cos(phi))+dp*TMath::Abs(TMath::Sin(phi));

    if ( Inside(xCross,yCross) )
      return fDetectorId;
    else
      return -1;
  }
  
  return -1;
}

void PndGemSensorMonitor::Print

(

)

Screen output

Definition at line 286 of file PndGemSensorMonitor.cxx.

References fBLATime, and fFLATime.

                                {
  cout << "---> sensor has " << fFLATime.size() << " Front and " << fBLATime.size() << " Back strips" << endl;

  for ( size_t ichan = 0 ; ichan < fFLATime.size() ; ichan++ ) {
    cout << ichan << ":" << fFLATime[ichan] << " . " << flush;
  }
  cout << endl;

  // for ( Int_t ibin = 0 ; ibin < 10 ; ibin++ ) {
  //   cout << " | " << flush;
  //   for ( Int_t ichan = 0 ; ichan < fFLATime.size() ; ichan+=10 ) {
  //     if ( fFNofDigis[ichan] == 0 ) {cout << " " << flush;continue;}
  //     cout << fFNofDigis[ichan] % 2 << flush;
  //     fFNofDigis[ichan] = fFNofDigis[ichan]/2;
  //   }
  //   cout << " | " << endl;
  // }
}

void PndGemSensor::Reset ( )

inherited

The index of the MCPoint that has caused a combination of front and back strip to be fired. Returns -1 for combinations of strips fired by different points (fake hits)

Parameters

iFStrip	Front strip number
iBStrip	Back strip number Index of MCPointClear the maps of fired strips

Definition at line 214 of file PndGemSensor.cxx.

Referenced by PndGemStation::Reset().

                         {
}

void PndGemSensor::SetDetectorId ( Int_t  stationNr, Int_t  sensorNr  )

inlineinherited

Definition at line 87 of file PndGemSensor.h.

References PndGemSensor::fDetectorId, and kGEM.

Referenced by PndGemSensor::PndGemSensor().

                                                           {
    fDetectorId = kGEM << 27 | 0 << 21 | stationNr << 8 | sensorNr << 6; }

Member Data Documentation

std::vector<Double_t> PndGemSensorMonitor::fBLACharge

private

Definition at line 114 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fBLADigiNr

private

Definition at line 115 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fBLAEventNr

private

Definition at line 116 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Double_t> PndGemSensorMonitor::fBLATime

private

Definition at line 113 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), ChannelLastActiveAt(), PndGemSensorMonitor(), and Print().

std::vector<Double_t> PndGemSensorMonitor::fBMeanTimeD

private

Definition at line 117 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fBNofDigis

private

Definition at line 118 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

Int_t PndGemSensorMonitor::fBSLChan

private

Definition at line 119 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel().

std::vector<Double_t> PndGemSensorMonitor::fFLACharge

private

Definition at line 106 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fFLADigiNr

private

Definition at line 107 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fFLAEventNr

private

Definition at line 108 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Double_t> PndGemSensorMonitor::fFLATime

private

----------— Data members -----------------------—

Definition at line 105 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), ChannelLastActiveAt(), PndGemSensorMonitor(), and Print().

std::vector<Double_t> PndGemSensorMonitor::fFMeanTimeD

private

Definition at line 109 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

std::vector<Int_t> PndGemSensorMonitor::fFNofDigis

private

Definition at line 110 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel(), and PndGemSensorMonitor().

Int_t PndGemSensorMonitor::fFSLChan

private

Definition at line 111 of file PndGemSensorMonitor.h.

Referenced by ActivateChannel().

Double_t PndGemSensorMonitor::fSensorFirstTime

private

Definition at line 122 of file PndGemSensorMonitor.h.

Double_t PndGemSensorMonitor::fSensorLastTime

private

Definition at line 123 of file PndGemSensorMonitor.h.

Double_t PndGemSensorMonitor::fSensorRecoveryTime

private

Definition at line 121 of file PndGemSensorMonitor.h.

---

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

• PndGemSensorMonitor.h
• PndGemSensorMonitor.cxx