PndLmdStripClusterTask Class Reference

#include <PndLmdStripClusterTask.h>

Inheritance diagram for PndLmdStripClusterTask:

Public Member Functions
	PndLmdStripClusterTask ()
virtual	~PndLmdStripClusterTask ()
virtual void	SetBranchNames (TString inBranchname, TString outHitBranchname, TString outClustBranchname, TString folderName)
virtual void	SetBranchNames ()
virtual void	SetParContainers ()
virtual void	SetCalculators ()
void	SetClusterType ()
TVector3	AddMSErr (TVector3 hit, TVector3 hiterr)
virtual Bool_t	Backmap (TVector2 meantopPoint, Double_t meantoperr, TVector2 meanbotPoint, Double_t meanboterr, TVector3 &hitPos, TMatrixD &hitCov, Int_t &sensorID)
void	Exec (Option_t *opt)
InitStatus	Init ()
void	SetMSflag (bool fflag)
	ClassDef (PndLmdStripClusterTask, 2)
virtual InitStatus	ReInit ()
virtual void	InitMQ (TList *tempList)
virtual void	GetParList (TList *)
virtual void	ExecMQ (TList *inputList, TList *outputList)
virtual void	SetParContainersMQ (TList *)
virtual void	SetInBranchId ()
virtual void	Finish ()
void	SetPersistency (Bool_t val=kTRUE)
Bool_t	GetPersistency ()

Public Attributes
PndGeoHandling *	fGeoH
FairRun *	ana
FairRuntimeDb *	rtdb

Protected Member Functions
TVector2	CalcLineCross (TVector2 point1, TVector2 dir1, TVector2 point2, TVector2 dir2) const
void	SetCurrentCalculators (PndSdsStripDigiPar *digipar)
Bool_t	SelectSensorParams (Int_t sensorID)
void	CalcMeanCharge (PndSdsClusterStrip *onecluster, Double_t &meanstrip, Double_t &meanerr, Double_t &charge, Double_t &timestamp, Double_t &timestampError)
void	Register ()
void	Reset ()
void	ProduceHits ()
void	ResetClusterFinders ()
void	FillClusterFinders ()
void	ClearCalculators ()
	ClassDef (PndSdsStripClusterTask, 2)
	ClassDef (PndSdsTask, 1)

Protected Attributes
TString	fPath
TClonesArray *	fDigiArray
TClonesArray *	fClusterArray
TClonesArray *	fHitArray
TString	fClustBranchName
Int_t	fClusterType
Int_t	fFEcolumns
Int_t	fFErows
Double_t	fChargeCut
Int_t	fRadChannel
Int_t	fRadTime
Double_t	fSingleStripChargeThreshold
FairEventHeader *	fEventHeader
TList *	fDigiParameterList
	Digitization Parameters. More...
PndSdsStripDigiPar *	fCurrentDigiPar
PndSensorNamePar *	fSensorNamePar
TList *	fChargeDigiParameterList
std::map< const char *, PndSdsCalcStrip * >	fStripCalcTop
	Calculator objects. More...
std::map< const char *, PndSdsCalcStrip * >	fStripCalcBot
std::map< const char *, PndSdsChargeConversion * >	fChargeConverter
PndSdsCalcStrip *	fCurrentStripCalcTop
PndSdsCalcStrip *	fCurrentStripCalcBot
PndSdsChargeWeightingAlgorithms *	fChargeAlgos
PndSdsChargeConversion *	fCurrentChargeConverter
PndSdsStripDigiPar *	fDigiPar
PndSdsStripClusterer *	fCurrentClusterfinder
	Geometry name handling. More...
std::map< const char *, PndSdsStripClusterer * >	fClusterFinderList
BinaryFunctor *	fFunctor
TString	fInBranchName
TString	fOutBranchName
TString	fFolderName
Int_t	fInBranchId
Int_t	fOutBranchId

Private Member Functions
void	combitransToLumiFrame (TVector3 &hitPos)
void	rotateToLumiFrame (TVector3 &hitPos)
TMatrixD	rotateToLumiFrame (TMatrixD &hitCov)

Private Attributes
bool	flagMS
Double_t	fPbeam

Detailed Description

Definition at line 12 of file PndLmdStripClusterTask.h.

Constructor & Destructor Documentation

PndLmdStripClusterTask::PndLmdStripClusterTask

(

)

Default constructor

Definition at line 28 of file PndLmdStripClusterTask.cxx.

References fGeoH, flagMS, and PndGeoHandling::Instance().

    : PndSdsStripClusterTask("LMD Strip Clusterisation Task") {
  fGeoH = PndGeoHandling::Instance();
  // fAlignParamList = new TList();
  flagMS = true;
}

PndLmdStripClusterTask::~PndLmdStripClusterTask ( )

virtual

Destructor

Definition at line 36 of file PndLmdStripClusterTask.cxx.

                                                {
  // if(0!=fGeoH)  delete fGeoH;
  // if(0!=fChargeAlgos) delete fChargeAlgos;
}

Member Function Documentation

TVector3 PndLmdStripClusterTask::AddMSErr	(	TVector3	hit,
		TVector3	hiterr
	)

Definition at line 220 of file PndLmdStripClusterTask.cxx.

References d, Double_t, fParticle, fPbeam, fVerbose, num, res, CAMath::Sqrt(), X, and xerr.

Referenced by Backmap().

                                                                         {
  if (fVerbose > 0)
    Info("AddMSErr",
         "calculation additional errors due to multiple scaterring");

  // Calculation of ThetaMS -------------------------------------
  // Charge & mass of particle
  Int_t PDGCode = -2212;
  TDatabasePDG* fdbPDG = TDatabasePDG::Instance();
  TParticlePDG* fParticle = fdbPDG->GetParticle(PDGCode);
  Double_t fMass = fParticle->Mass();

  Double_t Ebeam = TMath::Hypot(fPbeam, fMass);
  TLorentzVector LorMom(0, 0, fPbeam, Ebeam);
  Double_t beta = LorMom.Beta();
  Double_t X = 0.015;
  Double_t X0 = 9.37;
  // Double_t thetaMS =
  // 13.6*1e-3*TMath::Sqrt(X/X0)*(1+0.038*TMath::Log(X/X0))/(beta*fPbeam);
  Double_t thetaMS = 13.6 * 1e-3 * TMath::Sqrt(X / X0) / (beta * fPbeam);
  // cout<<"thetaMS = "<<thetaMS<<" fPbeam = "<<fPbeam<<endl;
  //-----------------------------------------------------------

  // TO DO: use parameters from geometry info for LUMI
  Double_t d = 10.;

  double xerr, yerr;
  double zhit = hpos.Z();
  //  const double Z0 = 1100.;
  const double Z0 = 1099.;
  // const double Z0 = 0.;
  int num = (zhit - Z0) / d;
  //  double numd = (zhit-Z0)/10.;
  // cout<<"num = "<<num<<endl;
  xerr = hposerr.X();
  yerr = hposerr.Y();
  // cout<<"Plane #"<<num<<" before: zhit="<<zhit<<" xerr = "<<xerr<<" yerr =
  // "<<yerr<<endl;
  // Double_t sigmaMSplane = 0.5*X*thetaMS; //TEST
  Double_t sigmaMSplane = X * thetaMS;
  //  cout<<"sigmaMSplane = "<<sigmaMSplane<<" um"<<endl;
  if (num == 0) {
    xerr = TMath::Hypot(xerr, sigmaMSplane);
    yerr = TMath::Hypot(yerr, sigmaMSplane);
  }
  // double xhit = hpos.X(); //[R.K. 01/2017] unused variable

  //  Double_t l = 10./cos(2.326*TMath::Pi()/180.);
  double sigmaMS;
  for (int j = 0; j < num; j++) {
    // sigmaMS = 2*(j+1)*d*thetaMS;
    sigmaMS = (j + 1) * d * thetaMS;
    // cout<<"sigmaMS = "<<sigmaMS<<" xerr="<<xerr<<" yerr="<<yerr<<endl;
    // sigmaMS = j*d*thetaMS;
    xerr = TMath::Hypot(xerr, sigmaMS);
    yerr = TMath::Hypot(yerr, sigmaMS);
  }
  if (fVerbose > 2)
    cout << " num:" << num << "(Z=" << zhit << ") xerr=" << xerr
         << " yerr=" << yerr << endl;
  TVector3 res(xerr, yerr, hposerr.Z());
  return res;
};

Bool_t PndLmdStripClusterTask::Backmap ( TVector2  meantopPoint, Double_t  meantoperr, TVector2  meanbotPoint, Double_t  meanboterr, TVector3 &  hitPos, TMatrixD &  hitCov, Int_t &  sensorID  )

virtual

TODO: think how to make alignment with using Kalman fillter

TODO: think how to make alignment with using Kalman fillter

Definition at line 612 of file PndLmdStripClusterTask.cxx.

References AddMSErr(), b, PndSdsStripClusterTask::CalcLineCross(), cos(), Double_t, fabs(), PndSdsStripClusterTask::fCurrentDigiPar, PndSdsStripClusterTask::fCurrentStripCalcBot, PndSdsStripClusterTask::fCurrentStripCalcTop, fGeoH, flagMS, PndSdsStripDigiPar::GetBotPitch(), PndSdsStripDigiPar::GetOrient(), PndGeoHandling::GetSensorDimensionsShortId(), PndSdsStripDigiPar::GetSkew(), PndSdsCalcStrip::GetStripDirection(), PndSdsStripDigiPar::GetTopAnchor(), PndSdsStripDigiPar::GetTopPitch(), PndGeoHandling::LocalToMasterErrorsShortId(), PndGeoHandling::LocalToMasterShortId(), sin(), sqrt(), CAMath::Sqrt(), and t.

Referenced by Exec().

                                                                          {
  // BACKMAPPING
  // get the backmapped point
  //  cout<<"PndLmdStripClusterTask::BACKMAP"<<endl;
  // Info("Backmap","Sensor ID is %s",sensorID);
  TVector3 localpos;
  TMatrixD locCov(3, 3);
  Double_t t, b;
  //  cout<<"sensorID = "<<sensorID<<endl;
  //  cout<<"fGeoH = "<<fGeoH<<endl;
  Double_t errZ =
      2. * fGeoH->GetSensorDimensionsShortId(sensorID).Z() / TMath::Sqrt(12.0);
  // cout<<"fGeoH->GetSensorDimensionsShortId(sensorID).Z() =
  // "<<fGeoH->GetSensorDimensionsShortId(sensorID).Z()<<endl;
  //  Double_t errZ =
  //  fGeoH->GetSensorDimensionsShortId(sensorID).Z()/TMath::Sqrt(12.0);//TEST!!!
  // cout<<"errZ = "<<errZ<<endl;

  TVector2 onsensorPoint =
      CalcLineCross(meantopPoint, fCurrentStripCalcTop->GetStripDirection(),
                    meanbotPoint, fCurrentStripCalcBot->GetStripDirection());
  // // here we assume the sensor system to be in the _Middle_ of the volume
  localpos.SetXYZ(onsensorPoint.X(), onsensorPoint.Y(), 0.);
  //  here we assume the sensor system to be in the _surface_ of the volume
  //  localpos.SetXYZ( onsensorPoint.X(),
  //  onsensorPoint.Y(),-(fGeoH->GetSensorDimensionsShortId(sensorID).Z()));
  // let's see if we're still on the sensor (cut combinations with noise off)
  if (fabs(localpos.X()) > fabs(fCurrentDigiPar->GetTopAnchor().X()))
    return kFALSE;
  if (fabs(localpos.Y()) > fabs(fCurrentDigiPar->GetTopAnchor().Y()))
    return kFALSE;

  // do the transformation from sensor to lab frame
  hitPos = fGeoH->LocalToMasterShortId(localpos, sensorID);

  // // //do the transformation from lab frame to LUMI frame (with z-axis perp.
  // to lumi planes)
  // combitransToLumiFrame(hitPos);

  // //do correction due to misalignemt of sensor
  // alignmentCorr(hitPos,sensorID);

  // calculate the errors corresponding to a skewed system!
  t = meantoperr * fCurrentDigiPar->GetTopPitch() *
      cos(fCurrentDigiPar->GetOrient());
  b = meanboterr * fCurrentDigiPar->GetBotPitch() *
      cos(fCurrentDigiPar->GetOrient() + fCurrentDigiPar->GetSkew());
  locCov[0][0] = t * t + b * b +
                 2 * fabs(t * b * cos(fCurrentDigiPar->GetSkew()));  // TEST
  t = meantoperr * fCurrentDigiPar->GetTopPitch() *
      sin(fCurrentDigiPar->GetOrient());
  b = meanboterr * fCurrentDigiPar->GetBotPitch() *
      sin(fCurrentDigiPar->GetOrient() + fCurrentDigiPar->GetSkew());
  locCov[1][1] = t * t + b * b +
                 2 * fabs(t * b * cos(fCurrentDigiPar->GetSkew()));  // TEST
  locCov[2][2] = errZ * errZ;

  if (flagMS) {
    // //Add uncertanty due to multiple scattering
    TVector3 hitErr(sqrt(locCov[0][0]), sqrt(locCov[1][1]), sqrt(locCov[2][2]));
    TVector3 hitErrMSadd = AddMSErr(hitPos, hitErr);
    locCov[0][0] = TMath::Power(hitErrMSadd.X(), 2);
    locCov[1][1] = TMath::Power(hitErrMSadd.Y(), 2);
    locCov[2][2] = TMath::Power(hitErrMSadd.Z(), 2);
  }

  // do the transformation from sensor to lab frame
  hitCov = fGeoH->LocalToMasterErrorsShortId(locCov, sensorID);

  // //transformation to LUMI frame
  // hitCov = rotateToLumiFrame(hitCov);

  return kTRUE;
}

TVector2 PndSdsStripClusterTask::CalcLineCross ( TVector2  point1, TVector2  dir1, TVector2  point2, TVector2  dir2  ) const

protectedinherited

Definition at line 614 of file PndSdsStripClusterTask.cxx.

References Double_t, dx, dy, s, x, and y.

Referenced by Backmap(), and PndSdsStripClusterTask::Backmap().

{
  Double_t dx, dy, s, M, x, y;
  dx = point2.X() - point1.X();
  dy = point2.Y() - point1.Y();
  
  M  = dir1.X()*dir2.Y() - dir1.Y()*dir2.X();
  
  if(M !=0.)
  {
    s  = dir1.Y()*dx/M - dir1.X()*dy/M;
    x  = point2.X() + dir2.X()*s;
    y  = point2.Y() + dir2.Y()*s;
  }
  else
  {
    std::cout<<"Warning in PndSdsStripClusterTask::CalcLineCross(): M=0 setting (x,y) to 0"<<std::endl;
    x=0.;y=0.;
  }
  
  TVector2 result(x,y);
  return result;
}

void PndSdsStripClusterTask::CalcMeanCharge ( PndSdsClusterStrip *  onecluster, Double_t &  meanstrip, Double_t &  meanerr, Double_t &  charge, Double_t &  timestamp, Double_t &  timestampError  )

protectedinherited

Definition at line 644 of file PndSdsStripClusterTask.cxx.

References PndSdsChargeWeightingAlgorithms::Binary(), PndSdsChargeWeightingAlgorithms::CenterOfGravity(), PndSdsChargeConversion::DigiValueToCharge(), Double_t, PndSdsChargeWeightingAlgorithms::Eta(), PndSdsStripClusterTask::eta_rect, PndSdsStripClusterTask::eta_trap, PndSdsStripClusterTask::fChargeAlgos, PndSdsStripClusterTask::fCurrentChargeConverter, PndSdsStripClusterTask::fCurrentDigiPar, PndSdsStripClusterTask::fDigiArray, PndSdsStripClusterTask::fGeoH, fVerbose, PndSdsCluster::GetClusterList(), PndSdsStripDigiPar::GetClusterMean(), PndSdsCluster::GetDigiIndex(), PndGeoHandling::GetPath(), PndSdsDigi::GetSensorID(), PndSdsChargeWeightingAlgorithms::HeadTail(), and sqrt().

Referenced by Exec(), and PndSdsStripClusterTask::Exec().

{
  meanstrip=0;
  meanerr=0;
  charge=0;
  timestamp=0;
  timestampError = 0;
  Int_t nDigis = 0;

//      if (fCurrentDigiPar->GetClusterMean() == 0)
//      {
//  // Calculate mean position in position channels weighted by the charges
//  Int_t strip;
//  SensorSide side;
//  Double_t tempcharge;
//  std::vector<Int_t> oneclusterlist = onecluster->GetClusterList();
//  for (std::vector<Int_t>::iterator itDigi = oneclusterlist.begin();
//       itDigi != oneclusterlist.end(); ++itDigi)
//  { // calculate the mean charge and stripnumber
//    PndSdsDigiStrip* myDigi = (PndSdsDigiStrip*)fDigiArray->At(*itDigi);
//    std::cout << "Digi: " << *myDigi << std::endl;
//    fCurrentStripCalcTop->CalcFeChToStrip(myDigi->GetFE(), myDigi->GetChannel(), strip, side);
//    tempcharge = fCurrentChargeConverter->DigiValueToCharge(*myDigi);
//    std::cout << "TempCharge: " << tempcharge << std::endl;
//    charge += tempcharge;
//    meanstrip += tempcharge * strip;
//    meanerr += tempcharge*tempcharge; // this is stupid, to be removed one day
//    Double_t var = myDigi->GetTimeStampError() * myDigi->GetTimeStampError();
//    timestamp += myDigi->GetTimeStamp()/var;
//    timestampError += 1/var;
//    nDigis++;
//  }
//  meanstrip = meanstrip/charge;
//  std::cout << "Charge: " << charge << std::endl;
//  // this error treatment is: dx = dpitch * sqrt(weigthsquares)
//  meanerr = sqrt(meanerr/(charge*charge));
//  if (nDigis > 0){
//      timestamp /= timestampError;
//      timestampError = sqrt(timestampError / nDigis);
//  }
//  return;
//      } else {
//  //  //TODO: Apply other clusterfinder mean & error algorithms
//  //    if(onecluster->GetSensorSide()==kTOP) fCurrentChargeAlgos->SetCalcStrip(fCurrentStripCalcTop);
//  //    else fCurrentChargeAlgos->SetCalcStrip(fCurrentStripCalcBot);
//  //    fChargeAlgos->SetChargeConverter(fCurrentChargeConverter); // done somewhere else
//  std::pair<Double_t,Double_t> result = fChargeAlgos->CenterOfGravity(onecluster);
//  meanstrip=result.first;
//  meanerr=result.second;
//  std::vector<Int_t> oneclusterlist = onecluster->GetClusterList();
//  for (std::vector<Int_t>::iterator itDigi = oneclusterlist.begin();
//       itDigi != oneclusterlist.end(); ++itDigi)
//  {
//    PndSdsDigiStrip* myDigi = (PndSdsDigiStrip*)fDigiArray->At(*itDigi);
//    std::cout << "Digi: " << * myDigi << std::endl;
//    std::cout << "TempCharge: " << fCurrentChargeConverter->DigiValueToCharge(*myDigi) << std::endl;
//    charge += fCurrentChargeConverter->DigiValueToCharge(*myDigi);
//    Double_t var = myDigi->GetTimeStampError() * myDigi->GetTimeStampError();
//    timestamp += myDigi->GetTimeStamp()/var;
//    timestampError += 1/var;
//    nDigis++;
//  }
//  if (nDigis > 0){
//      timestamp /= timestampError;
//      timestampError = sqrt(timestampError / nDigis);
//  }
//
//  std::cout << "Charge: " << charge << std::endl;
//  return;
//      }

  Int_t centroidMod = fCurrentDigiPar->GetClusterMean();
  PndSdsDigiStrip* tmpdigi=0;
  
  std::pair<Double_t,Double_t> result;
  
  switch(centroidMod){ // Select a method by the number of the CenteroidAlgorithm
      
    case 1:
      // Binary (hightest signal)
      result = fChargeAlgos->Binary(onecluster);
      break;
      
    case 2:
      //Center of Gravity, Binary for cluster size 1
      result = fChargeAlgos->CenterOfGravity(onecluster);
      break;
      
    case 3:
      // Eta Algorithm for cluster size 2, Binary for cluster size 1, else CoG   
      tmpdigi = (PndSdsDigiStrip*)(fDigiArray->At(onecluster->GetDigiIndex(0)));
      if(fGeoH->GetPath(tmpdigi->GetSensorID()).Contains("Fwd")) 
        result = fChargeAlgos->Eta(onecluster, eta_trap);
      else result = fChargeAlgos->Eta(onecluster, eta_rect);
      break;
      
    case 4:
      // Head-Tail, Binary for cluster size 1
      result = fChargeAlgos->HeadTail(onecluster);
      break;
      
      //Center of Gravity, Binary for cluster size 1
    default:
      result = fChargeAlgos->CenterOfGravity(onecluster);
      break;
  }
  
  meanstrip=result.first;
  meanerr=result.second;
  
  std::vector<Int_t> oneclusterlist = onecluster->GetClusterList();
  for (std::vector<Int_t>::iterator itDigi = oneclusterlist.begin();
       itDigi != oneclusterlist.end(); ++itDigi)
  {
    tmpdigi = (PndSdsDigiStrip*)fDigiArray->At(*itDigi);
    if(fVerbose>3) Info("CalcMeanCharge:","Added charge of digi %i in cluster is %f",nDigis,fCurrentChargeConverter->DigiValueToCharge(*tmpdigi));
    charge += fCurrentChargeConverter->DigiValueToCharge(*tmpdigi);
    Double_t var = tmpdigi->GetTimeStampError() * tmpdigi->GetTimeStampError();
    timestamp += tmpdigi->GetTimeStamp()/var;
    timestampError += 1/var;
    nDigis++;
  }
  if (nDigis > 0){
    timestamp /= timestampError;
    timestampError = sqrt(timestampError / nDigis);
  }
  return;
}

PndLmdStripClusterTask::ClassDef	(	PndLmdStripClusterTask	,
		2
	)

PndSdsTask::ClassDef ( PndSdsTask  , 1    )

protectedinherited

PndSdsStripClusterTask::ClassDef ( PndSdsStripClusterTask  , 2    )

protectedinherited

void PndSdsStripClusterTask::ClearCalculators ( )

protectedinherited

Definition at line 124 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::fChargeAlgos, PndSdsStripClusterTask::fChargeConverter, PndSdsStripClusterTask::fClusterFinderList, PndSdsStripClusterTask::fCurrentChargeConverter, PndSdsStripClusterTask::fCurrentClusterfinder, PndSdsStripClusterTask::fCurrentStripCalcBot, PndSdsStripClusterTask::fCurrentStripCalcTop, PndSdsStripClusterTask::fStripCalcBot, and PndSdsStripClusterTask::fStripCalcTop.

Referenced by PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::~PndSdsStripClusterTask().

{
  for( std::map<const char*,PndSdsCalcStrip*>::iterator it = fStripCalcTop.begin(); it != fStripCalcTop.end(); it++){
    if(0 != it->second) delete it->second;
    it->second = 0;
  }
  for( std::map<const char*,PndSdsCalcStrip*>::iterator it = fStripCalcBot.begin(); it != fStripCalcBot.end(); it++){
    if(0 != it->second) delete it->second;
    it->second = 0;
  }
  if(0 != fChargeAlgos) delete fChargeAlgos;
  for(std::map<const char*,PndSdsChargeConversion*>::iterator it = fChargeConverter.begin(); it != fChargeConverter.end(); it++){
    if(0 != it->second) delete it->second;
    it->second = 0;
  }  
  for(std::map<const char*,PndSdsStripClusterer*>::iterator it = fClusterFinderList.begin(); it != fClusterFinderList.end(); it++){
    if(0 != it->second) delete it->second;
    it->second = 0;
  }  
  
  fCurrentChargeConverter=0;
  fCurrentStripCalcTop=0;
  fCurrentStripCalcBot=0;
  fCurrentClusterfinder=0;  
}

void PndLmdStripClusterTask::combitransToLumiFrame ( TVector3 &  hitPos )

private

Definition at line 547 of file PndLmdStripClusterTask.cxx.

References Double_t.

                                                                   {
  // do the transformation from lab frame to LUMI frame (with z-axis perp. to
  // lumi planes)
  // const Double_t  kHalfFoilThickness  = 0.0075; // Thickness of sensitive
  // foil (cm) //[R.K. 01/2017] unused variable
  const Double_t kTransZ = 1100.;   //(cm) //move at z-position
  const Double_t kRotUmZ = 476.03;  //(cm) //z-point to rotate
  // const Double_t  kTransX = 25; //(cm) //move at x-position //[R.K. 01/2017]
  // unused variable
  const Double_t kRot =
      0.040596358401388;  // 2.326 degree  = 4.05963584013881024e-02 rad
  TVector3 LumiTrans(0, 0, kRotUmZ);
  hitPos -= LumiTrans;
  hitPos.RotateY(-kRot);
  LumiTrans = TVector3(0, 0, kTransZ - kRotUmZ);
  hitPos -= LumiTrans;
  // cout<<"!!! NEW HIT position in LUMI frame!!! "<<endl;
  //  hitPos.Print();
}

void PndLmdStripClusterTask::Exec ( Option_t *  opt )

virtual

Virtual method Exec

Reimplemented from PndSdsStripClusterTask.

Definition at line 285 of file PndLmdStripClusterTask.cxx.

References Backmap(), Bool_t, PndSdsStripClusterTask::CalcMeanCharge(), PndSdsCalcStrip::CalcStripPointOnLine(), Double_t, fabs(), PndSdsStripClusterTask::fChargeCut, PndSdsStripClusterTask::fClustBranchName, PndSdsStripClusterTask::fClusterArray, PndSdsStripClusterTask::fClusterType, PndSdsStripClusterTask::fCurrentClusterfinder, PndSdsStripClusterTask::fCurrentStripCalcBot, PndSdsStripClusterTask::fCurrentStripCalcTop, PndSdsStripClusterTask::fDigiArray, PndSdsStripClusterTask::fDigiParameterList, PndSdsStripClusterTask::fFunctor, fGeoH, PndSdsStripClusterTask::fHitArray, PndSdsStripClusterTask::FillClusterFinders(), PndSdsTask::fInBranchName, PndSdsTask::fOutBranchName, PndSdsStripClusterTask::fSingleStripChargeThreshold, fVerbose, PndSdsStripClusterer::GetBotClusterIDs(), PndSdsCluster::GetClusterList(), PndSdsCluster::GetClusterSize(), PndSdsCluster::GetDigiIndex(), PndSdsDigi::GetIndex(), PndSdsStripClusterer::GetLeftDigiIDs(), PndSdsDigi::GetNIndices(), PndSdsDigi::GetSensorID(), PndSdsStripClusterer::GetTopClusterIDs(), i, PndSdsHit::Print(), s, PndSdsStripClusterer::SearchClusters(), PndSdsHit::SetBotIndex(), PndSdsHit::SetCov(), PndSdsStripClusterTask::SetCurrentCalculators(), PndGeoHandling::SetVerbose(), and sqrt().

                                           {
  if (fVerbose > 2)
    std::cout << " **Starting PndLmdStripClusterTask::Exec()**" << std::endl;
  std::vector<PndSdsDigiStrip> digiStripArray;
  // Reset output array
  fClusterArray =
      FairRootManager::Instance()->GetTClonesArray(fClustBranchName);
  if (!fClusterArray) Fatal("Exec", "No ClusterArray");
  fClusterArray->Delete();

  fHitArray = FairRootManager::Instance()->GetTClonesArray(fOutBranchName);
  if (!fHitArray) Fatal("Exec", "No HitArray");
  fHitArray->Delete();

  // Get input array

  if (FairRunAna::Instance()->IsTimeStamp()) {
    fDigiArray->Clear();
    fDigiArray = FairRootManager::Instance()->GetData(
        fInBranchName, fFunctor,
        FairRootManager::Instance()->GetEventTime() +
            10);  // FairRootManager::Instance()->GetEventTime() +
    if (fVerbose > 1)
      std::cout << "-I- PndLmdStripClusterTask::Exec Digis: "
                << fDigiArray->GetEntries() << std::endl;
  } else
    fDigiArray =
        (TClonesArray*)FairRootManager::Instance()->GetObject(fInBranchName);

  if (!fDigiArray) {
    std::cout << "-W- PndLmdStripClusterTask::Init: "
              << "No LMDDigi array!" << std::endl;
    return;
  }

  // when we have no digis, we can end the event here.
  if (fDigiArray->GetEntriesFast() == 0) return;
  fGeoH->SetVerbose(fVerbose);

  // Setup
  FillClusterFinders();

  std::vector<PndSdsClusterStrip*> clusters;
  std::vector<Int_t> topclusters;  // contains index to fClusterArray
  std::vector<Int_t> botclusters;  // contains index to fClusterArray
  std::vector<Int_t> oneclustertop;
  std::vector<Int_t> oneclusterbot;
  std::vector<Int_t> leftDigis;
  Int_t mcindex, clindex, botIndex, topIndex;
  // Int_t detID = FairRootManager::Instance()->GetBranchId(fInBranchName);
  // //[R.K. 01/2017] unused variable
  Int_t clDetID = FairRootManager::Instance()->GetBranchId(fClustBranchName);
  Double_t mycharge;
  TVector2 meantopPoint, meanbotPoint, onsensorPoint;
  TVector3 hitPos, hitErr;
  TMatrixD hitCov(3, 3);
  Int_t clusterOffset = 0;
  PndSdsHit* tmphit;

  // -------   SEARCH  ------
  TIter parsetiter(fDigiParameterList);
  while (PndSdsStripDigiPar* digipar = (PndSdsStripDigiPar*)
             parsetiter()) {  // loop over all parameter sets and their filled
                              // finders (representing sensor types)
    SetCurrentCalculators(digipar);

    clusters = fCurrentClusterfinder->SearchClusters();
    // fetch ids in 'clusters' to the top and bot side
    topclusters = fCurrentClusterfinder->GetTopClusterIDs();
    botclusters = fCurrentClusterfinder->GetBotClusterIDs();
    if (fVerbose > 2) {
      leftDigis = fCurrentClusterfinder->GetLeftDigiIDs();
      if (0 < leftDigis.size()) {
        std::cout << "There are " << leftDigis.size()
                  << " Digis not assigned to"
                  << " clusters:\n";
        for (unsigned int s = 0; s < leftDigis.size(); s++) {
          std::cout << leftDigis[s] << "|";
        }
        std::cout << std::endl;
      } else
        std::cout << "All Digis assigned to clusters" << std::endl;
    }
    // Fill the ClonesArray for output TODO: do this better, don't copy objects
    // around
    // save array size before we fill
    clusterOffset = fClusterArray->GetEntriesFast();
    for (std::vector<PndSdsClusterStrip*>::iterator clit = clusters.begin();
         clit != clusters.end(); ++clit) {
      clindex = fClusterArray->GetEntriesFast();
      PndSdsClusterStrip* myCluster =
          new ((*fClusterArray)[clindex]) PndSdsClusterStrip(*(*clit));

      if (FairRunAna::Instance()->IsTimeStamp()) {
        myCluster->ResetLinks();
        for (Int_t i = 0; i < myCluster->GetClusterSize(); i++) {
          PndSdsDigiStrip* tempDigi =
              (PndSdsDigiStrip*)fDigiArray->At(myCluster->GetDigiIndex(i));
          myCluster->AddLink(FairLink(tempDigi->GetEntryNr()));
        }
      }
    }

    // printout for checking
    if (fVerbose > 2) {
      std::cout << "Check.. Offset: " << clusterOffset << "Top Clusters: ";
      for (std::vector<Int_t>::iterator itTop = topclusters.begin();
           itTop != topclusters.end(); ++itTop) {
        std::cout << *itTop << " | ";
      }
      std::cout << std::endl;
      std::cout << "Bot Clusters: ";
      for (std::vector<Int_t>::iterator itBot = botclusters.begin();
           itBot != botclusters.end(); ++itBot) {
        std::cout << *itBot << " | ";
      }
      std::cout << std::endl;
    }

    // begin the hit reconstruction
    // loop structure:
    //
    // top clusters
    // |-calculate chargeweighted mean
    // |-bot clusters
    // |-|-calc chargew. mean
    // |-|-calc the crossing strip points
    // |-|-fill hit array

    // -----  merge top/bot clusters to hits  -----
    // loop on clusters from the top side
    for (std::vector<Int_t>::iterator itTop = topclusters.begin();
         itTop != topclusters.end(); ++itTop) {
      topIndex = *itTop + clusterOffset;  // index in fClusterArray
      Double_t topcharge = 0., meantopstrip = 0., meantoperr = 0.,
               timestamp = 0., timestampError = 0.;
      PndSdsClusterStrip* aTopCluster = clusters[*itTop];
      oneclustertop = aTopCluster->GetClusterList();
      if (oneclustertop.size() < 1) continue;
      PndSdsDigiStrip* atopDigi =
          ((PndSdsDigiStrip*)fDigiArray->At(oneclustertop[0]));
      Int_t sensorIDtop = atopDigi->GetSensorID();

      // if (kFALSE==SelectSensorParams(detName)) continue; // Invalid
      // parameters, skip here.
      CalcMeanCharge(aTopCluster, meantopstrip, meantoperr, topcharge,
                     timestamp, timestampError);

      if (oneclustertop.size() == 1 &&
          topcharge < fSingleStripChargeThreshold) {
        std::cout << "-W- PndLmdStripClusterTask::Exec: Single strip charge ("
                  << topcharge << " e-) falls below the threshold of "
                  << fSingleStripChargeThreshold << "e- : skipping. " << endl;
        continue;
      }
      if (topcharge <= 0) {  // not a sane charge
        Error("Exec() - Hit combination",
              "Not a sane top charge (%f) calculated, skip cluster %i",
              topcharge, *itTop);
        continue;
      }
      if (meantopstrip < 0) {  // not a sane strip number
        Error("Exec() - Hit combination",
              "Not a sane top mean (%f) calculated, skip cluster %i",
              meantopstrip, *itTop);
        continue;
      }
      fCurrentStripCalcTop->CalcStripPointOnLine(meantopstrip, meantopPoint);
      // loop on bottom side
      for (std::vector<Int_t>::iterator itBot = botclusters.begin();
           itBot != botclusters.end(); ++itBot) {
        botIndex = *itBot + clusterOffset;  // index in fClusterArray
        Double_t botcharge = 0., meanbotstrip = 0., meanboterr = 0.;
        PndSdsClusterStrip* aBotCluster = clusters[*itBot];
        oneclusterbot = aBotCluster->GetClusterList();
        if (oneclusterbot.size() < 1) continue;
        PndSdsDigiStrip* abotDigi =
            ((PndSdsDigiStrip*)fDigiArray->At(oneclusterbot[0]));
        Int_t sensorIDbot = abotDigi->GetSensorID();

        // go to the next cluster if we didn't hit the same sensor
        if (sensorIDbot != sensorIDtop) continue;

        CalcMeanCharge(aBotCluster, meanbotstrip, meanboterr, botcharge,
                       timestamp, timestampError);

        if (oneclusterbot.size() == 1 &&
            botcharge < fSingleStripChargeThreshold) {
          std::cout << "-W- PndLmdStripClusterTask::Exec: Single strip charge ("
                    << botcharge << " e-) falls below the threshold of "
                    << fSingleStripChargeThreshold << "e- : skipping. " << endl;
          continue;
        }
        if (botcharge <= 0) {  // not a sane charge
          Error("Exec() - Hit combination",
                "Not a sane bot charge (%f) calculated, skip cluster %i",
                botcharge, *itBot);
          continue;
        }
        if (meanbotstrip < 0) {  // not a sane strip number
          Error("Exec() - Hit combination",
                "Not a sane bot mean (%f) calculated, skip cluster %i",
                meanbotstrip, *itBot);
          continue;
        }

        if (fVerbose > 2) {
          std::cout << "Charges: Ctop = " << topcharge
                    << " | Cbot = " << botcharge
                    << " | difference bot-top = " << botcharge - topcharge
                    << " | Cut at " << fChargeCut << std::endl;
        }

        if (fChargeCut > 0 &&
            fabs(botcharge - topcharge) <
                fChargeCut) {  // look if the charges are not too differently
          mycharge = (botcharge + topcharge) / 2.;
          fCurrentStripCalcBot->CalcStripPointOnLine(meanbotstrip,
                                                     meanbotPoint);
          mcindex = -1;  // reset
          for (Int_t mcI = 0; mcI < atopDigi->GetNIndices(); mcI++) {
            if (atopDigi->GetIndex(mcI) > -1) {
              for (Int_t mcIb = 0; mcIb < abotDigi->GetNIndices(); mcIb++) {
                if (abotDigi->GetIndex(mcIb) == atopDigi->GetIndex(mcI)) {
                  mcindex = abotDigi->GetIndex(mcIb);
                  break;
                }
              }
            }
          }
          Bool_t test = Backmap(meantopPoint, meantoperr, meanbotPoint,
                                meanboterr, hitPos, hitCov, sensorIDtop);
          if (kFALSE == test) continue;

          // --- add hit to list ---
          Int_t i = fHitArray->GetEntriesFast();
          hitErr.SetXYZ(sqrt(hitCov[0][0]), sqrt(hitCov[1][1]),
                        sqrt(hitCov[2][2]));
          tmphit = new ((*fHitArray)[i]) PndSdsHit(
              clDetID, sensorIDtop, hitPos, hitErr, topIndex, mycharge,
              oneclusterbot.size() + oneclustertop.size(), mcindex);
          tmphit->SetBotIndex(botIndex);
          tmphit->SetLink(FairLink(fClusterType, topIndex));
          tmphit->AddLink(FairLink(fClusterType, botIndex));
          tmphit->SetCov(hitCov);
          tmphit->SetTimeStamp(timestamp);
          tmphit->SetTimeStampError(timestampError);
          if (fVerbose > 1) tmphit->Print();
        } else if (fVerbose > 2)
          std::cout << "Strip charge contents too different" << std::endl;
      }  // loop bot clusters
    }    // loop top clusters
  }      // loop finders

  if (fVerbose > 1)
    std::cout << "-I- PndLmdStripClusterTask: "
              << fClusterArray->GetEntriesFast() << " Lmd Clusters and "
              << fHitArray->GetEntriesFast() << " Hits calculated."
              << " out of " << fDigiArray->GetEntriesFast() << " Digis"
              << std::endl;
  return;
}

void PndSdsStripClusterTask::ExecMQ ( TList *  inputList, TList *  outputList  )

virtualinherited

Definition at line 177 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::fClusterArray, PndSdsStripClusterTask::fDigiArray, PndSdsStripClusterTask::fEventHeader, and PndSdsStripClusterTask::fHitArray.

{
//      LOG(INFO) << "PndSdsStripClusterTask::ExecMQ inBranchName " << fInBranchName.Data() << FairLogger::endl;
//      LOG(INFO) << "InputList: " << inputList->GetEntries() << FairLogger::endl;
//      TIter next(inputList);
//      while(TObject* obj = next()){
//              LOG(INFO) << obj->GetName() << FairLogger::endl;
//      }
        fDigiArray = (TClonesArray*) inputList->FindObject("PndSdsDigiStrips");
        fEventHeader = (FairEventHeader*) inputList->FindObject("EventHeader.");
        LOG(INFO) << "DigiArray: " << fDigiArray << FairLogger::endl;
        LOG(INFO) << "DigiArray: " << fDigiArray->GetEntriesFast() << FairLogger::endl;


        outputList->Add(fClusterArray);
        outputList->Add(fHitArray);
        Exec("");
        return;
}

void PndSdsStripClusterTask::FillClusterFinders ( )

protectedinherited

Definition at line 583 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterer::AddDigi(), Bool_t, PndSdsCalcStrip::CalcFeChToStrip(), PndSdsStripClusterTask::fChargeAlgos, PndSdsStripClusterTask::fCurrentClusterfinder, PndSdsStripClusterTask::fCurrentStripCalcTop, PndSdsStripClusterTask::fDigiArray, PndSdsStripClusterTask::fGeoH, fVerbose, PndSdsDigiStrip::GetChannel(), PndSdsDigi::GetFE(), PndGeoHandling::GetPath(), PndSdsDigi::GetSensorID(), PndSdsDigiStrip::Print(), PndSdsStripClusterTask::ResetClusterFinders(), PndSdsStripClusterTask::SelectSensorParams(), PndSdsChargeWeightingAlgorithms::SetDigiArray(), and strip.

Referenced by Exec(), and PndSdsStripClusterTask::Exec().

{
  // Info("FillClusterFinders","Here! fCurrntClusterfinder:%p",fCurrentClusterfinder);
  ResetClusterFinders();
  // a std::map is a SORTED container, it is sorted by the identifier
  Int_t sensorID;
  Int_t strip;
  SensorSide side;
  PndSdsDigiStrip* myDigi=0;
  Bool_t tester=kFALSE;
  // Sort Digi indice into the clusterfinder
  if (fDigiArray->GetEntriesFast() == 0) return;
  if(fVerbose>2) Info("FillClusterFinders","adding these digis to the finders:"); 
  for (Int_t iDigi = 0; iDigi < fDigiArray->GetEntriesFast(); iDigi++)
  { // sort digis by sensor name and stripnumber
    myDigi = (PndSdsDigiStrip*)(fDigiArray->At(iDigi));
    if(fVerbose>2) {std::cout<<"Digi "<<iDigi<<" "; myDigi->Print(); std::cout << fGeoH->GetPath(myDigi->GetSensorID()) << std::endl;}
    sensorID = myDigi->GetSensorID();
    tester=SelectSensorParams(sensorID);
    if (kFALSE==tester) continue; // Invalid parameters, skip here.
    //we use the top side as "first" side
    fCurrentStripCalcTop->CalcFeChToStrip(myDigi->GetFE(), myDigi->GetChannel(), strip, side); 
    // Time stamp measured in ns, cropped to integer for clusterfinding
    //fCurrentClusterfinder->AddDigi(sensorID,side,(Int_t)myDigi->GetTimeStamp(),strip,iDigi);
    fCurrentClusterfinder->AddDigi(sensorID,side,1,strip,iDigi);
  } 
  // make sure the digi array is distributed well
  fChargeAlgos->SetDigiArray(fDigiArray);
}

void PndSdsStripClusterTask::Finish ( )

virtualinherited

Virtual method Finish

Definition at line 640 of file PndSdsStripClusterTask.cxx.

{
}

virtual void PndSdsStripClusterTask::GetParList ( TList *  )

inlinevirtualinherited

Reimplemented in PndMvdStripClusterTask.

Definition at line 125 of file PndSdsStripClusterTask.h.

{};// tempList //[R.K.03/2017] unused variable(s)

Bool_t PndPersistencyTask::GetPersistency ( )

inlineinherited

Definition at line 32 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency.

Referenced by PndLmdPixelHitProducerFast::GetPersistance(), PndMdtDigitization::Init(), PndMdtHitProducerIdeal::Init(), PndMdtClusterTask::Init(), PndFtsHitProducerRealFast::Init(), PndSttHitProducerRealFast::Init(), PndDiscTaskReconstruction::Init(), PndRichHitProducer::Init(), PndSttHelixHitProducer::Init(), PndDiscTaskPID::Init(), PndIdealTrackFinder::Init(), PndSttMvdGemTracking::Init(), PndMdtTrkProducer::Init(), PndFtsHitProducerRealFull::Init(), PndLmdPixelClusterTask::Init(), PndSttHitProducerRealFull::Init(), Init(), PndEmcApdHitProducer::Init(), PndMissingPzCleanerTask::Init(), PndEmcMakeRecoHit::Init(), PndEmcMakeClusterOnline::Init(), PndTrackSmearTask::Init(), PndEmcFWEndcapTimebasedWaveforms::Init(), PndSttHitProducerIdeal::Init(), PndEmcFWEndcapDigi::Init(), PndFtsHitProducerIdeal::Init(), PndEmcMakeCluster::Init(), PndMdtPointsToWaveform::Init(), PndDiscTaskDigitization::Init(), PndEmcMakeDigi::Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndDrcHitFinder::Init(), PndRichHitFinder::Init(), PndEmcMakeCorr::Init(), PndFtofHitProducerIdeal::Init(), PndEmcHitsToWaveform::Init(), PndSciTDigiTask::Init(), PndDrcHitProducerIdeal::Init(), PndSdsHitProducerIdeal::Init(), PndSciTHitProducerIdeal::Init(), PndRecoMultiKalmanTask2::Init(), PndEmcHitProducer::Init(), PndDrcHitProducerReal::Init(), PndDskFLGHitProducerIdeal::Init(), PndEmcTmpWaveformToDigi::Init(), PndDrcDigiTask::Init(), PndEmcWaveformToDigi::Init(), PndSttMatchTracks::Init(), PndEmcWaveformToCalibratedDigi::Init(), PndTrkTracking2::Init(), PndSttFindTracks::Init(), PndEmcMultiWaveformToCalibratedDigi::Init(), PndRecoKalmanTask2::Init(), PndDrcTimeDigiTask::Init(), PndEmcExpClusterSplitter::Init(), PndFtsHoughTrackerTask::Init(), PndSdsNoiseProducer::Init(), PndEmcPhiBumpSplitter::Init(), PndSdsIdealRecoTask::Init(), PndSdsHybridHitProducer::Init(), PndRecoMultiKalmanTask::Init(), PndSdsIdealClusterTask::Init(), PndRecoKalmanTask::Init(), PndSdsStripHitProducerDif::Init(), PndGemDigitize::Init(), PndSdsStripHitProducer::Init(), PndGemFindHits::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndMvdGemTrackFinderOnHits::Init(), PndBarrelTrackFinder::Init(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcMakeBump::PndEmcMakeBump(), PndUnassignedHitsTask::RegisterBranches(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndEmcMakeBump::SetStorageOfData(), and PndEmcFullDigiTask::StoreDigi().

{ return fPersistency; }

InitStatus PndLmdStripClusterTask::Init ( )

virtual

Reimplemented from PndSdsStripClusterTask.

Definition at line 43 of file PndLmdStripClusterTask.cxx.

References PndSdsStripClusterTask::fClustBranchName, PndSdsStripClusterTask::fClusterArray, PndSdsStripClusterTask::fDigiArray, PndSdsTask::fFolderName, PndSdsStripClusterTask::fFunctor, PndSdsStripClusterTask::fHitArray, PndSdsTask::fInBranchName, PndSdsTask::fOutBranchName, fPbeam, PndPersistencyTask::GetPersistency(), par, rtdb, SetBranchNames(), SetCalculators(), and PndSdsStripClusterTask::SetInBranchId().

Referenced by runReco().

                                        {
  FairBaseParSet* par =
      (FairBaseParSet*)(rtdb->findContainer("FairBaseParSet"));
  fPbeam = par->GetBeamMom();

  SetBranchNames();

  FairRootManager* ioman = FairRootManager::Instance();
  if (!ioman) {
    std::cout << "-E- PndSdsStripClusterTask::Init: "
              << "RootManager not instantiated!" << std::endl;
    return kFATAL;
  }

  fFunctor = new TimeGap();

  // Get input array
  fDigiArray = (TClonesArray*)ioman->GetObject(fInBranchName);
  //
  if (!fDigiArray) {
    std::cout << "-W- PndSdsStripClusterTask::Init: "
              << "No SDSDigi array!" << std::endl;
    return kERROR;
  }
  // set output arrays

  fClusterArray = ioman->Register(fClustBranchName, "PndSdsClusterStrip",
                                  fFolderName, GetPersistency());

  // fHitArray = new TClonesArray("PndSdsHit");
  fHitArray =
      ioman->Register(fOutBranchName, "PndSdsHit", fFolderName, GetPersistency());

  SetInBranchId();

  SetCalculators();

  // fPath = getenv("VMCWORKDIR");
  // fPath += "/macro/params/interstrippos_vs_eta_histos.root";

  // etahistofile = new TFile(fPath,"READ");
  // eta_rect = (TH1F*)etahistofile->Get("posvseta rect");
  // eta_trap = (TH1F*)etahistofile->Get("posvseta trap");

  Info("Init", "Initialisation successfull");
  return kSUCCESS;
}

void PndSdsStripClusterTask::InitMQ ( TList *  tempList )

virtualinherited

Definition at line 161 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::fClusterArray, PndSdsStripClusterTask::fGeoH, PndSdsStripClusterTask::fHitArray, PndGeoHandling::FillSensorMap(), PndSdsStripClusterTask::fSensorNamePar, PndSdsTask::SetBranchNames(), PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetParContainersMQ().

{
        SetBranchNames();
        fHitArray = new TClonesArray("PndSdsHit",10000);
        fHitArray->SetName("MVDHitsStrip");
        fClusterArray = new TClonesArray("PndSdsClusterStrip", 10000);
        fClusterArray->SetName("MVDStripCluster");

        fSensorNamePar = (PndSensorNamePar*)tempList->FindObject("PndSensorNamePar");
        fGeoH = new PndGeoHandling(fSensorNamePar);
        fGeoH->FillSensorMap();

        SetParContainersMQ(tempList);
        SetCalculators();
}

void PndSdsStripClusterTask::ProduceHits ( )

protectedinherited

void PndSdsStripClusterTask::Register ( )

protectedinherited

InitStatus PndSdsStripClusterTask::ReInit ( )

virtualinherited

Definition at line 198 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetParContainers().

{  
  SetParContainers(); 
  SetCalculators();
  return kSUCCESS;
}

void PndSdsStripClusterTask::Reset ( )

protectedinherited

void PndSdsStripClusterTask::ResetClusterFinders ( )

protectedinherited

Definition at line 573 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::fClusterFinderList.

Referenced by PndSdsStripClusterTask::FillClusterFinders().

{ 
  //recursively clean the digis in the clusterfinder objects each event 
  for(std::map<const char*,PndSdsStripClusterer*>::iterator CFiter = fClusterFinderList.begin(); 
      CFiter != fClusterFinderList.end(); CFiter++) 
  { 
    (CFiter->second)->Reinit(); 
  } 
} 

void PndLmdStripClusterTask::rotateToLumiFrame ( TVector3 &  hitPos )

private

Definition at line 567 of file PndLmdStripClusterTask.cxx.

References res.

                                                               {
  TMatrixD hitMtx(3, 3);
  hitMtx[0][0] = hitPos[0];
  hitMtx[1][0] = hitPos[1];
  hitMtx[2][0] = hitPos[2];
  TMatrixD res = rotateToLumiFrame(hitMtx);
  hitPos = TVector3(hitMtx(0, 0), hitMtx(1, 0), hitMtx(2, 0));
}

TMatrixD PndLmdStripClusterTask::rotateToLumiFrame ( TMatrixD &  hitCov )

private

Definition at line 575 of file PndLmdStripClusterTask.cxx.

References CAMath::Cos(), Double_t, Pi, rot, CAMath::Sin(), and theta.

                                                                   {
  Double_t theta = 2.326;
  Double_t degrad = TMath::Pi() / 180.;
  Double_t sintheta = TMath::Sin(degrad * theta);
  Double_t costheta = TMath::Cos(degrad * theta);
  TMatrixD rot(3, 3);  // Rotation around Y axis
  rot[0][0] = costheta;
  rot[0][1] = 0;
  rot[0][2] = sintheta;
  rot[1][0] = 0;
  rot[1][1] = 1;
  rot[1][2] = 0;
  rot[2][0] = -sintheta;
  rot[2][1] = 0;
  rot[2][2] = costheta;
  TMatrixD result = rot;
  result.T();
  result *= hitCov;
  hitCov = result;
  result *= rot;
  return result;
}

Bool_t PndSdsStripClusterTask::SelectSensorParams ( Int_t  sensorID )

protectedinherited

Definition at line 536 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::fDigiParameterList, PndSdsStripClusterTask::fGeoH, fVerbose, PndGeoHandling::GetPath(), PndSdsStripClusterTask::SetCurrentCalculators(), and TString.

Referenced by PndSdsStripClusterTask::FillClusterFinders().

{
  TString detpath = fGeoH->GetPath(sensorID);
  if( !(detpath.Contains("Strip")) ) 
    return kFALSE; 
  TIter parsetiter(fDigiParameterList);
  while ( PndSdsStripDigiPar* digipar = (PndSdsStripDigiPar*)parsetiter() )  
  { 
    const char* sensortype = digipar->GetSensType();
    if(detpath.Contains(sensortype))  {
      SetCurrentCalculators(digipar);
      return kTRUE; 
    } 
  } 
  // no suiting object found 
  if (fVerbose > 1) std::cout<<"detector name does not contain a valid parameter name."<<std::endl; 
  if (fVerbose > 2) std::cout<<" DetName : "<<detpath<<std::endl; 
  return kFALSE; 
} 

void PndLmdStripClusterTask::SetBranchNames ( TString  inBranchname, TString  outHitBranchname, TString  outClustBranchname, TString  folderName  )

virtual

Virtual method Init

Definition at line 92 of file PndLmdStripClusterTask.cxx.

References PndSdsStripClusterTask::fClustBranchName, PndSdsTask::fFolderName, PndSdsTask::fInBranchName, and PndSdsTask::fOutBranchName.

                                                                {
  fInBranchName = inBranchname;
  fOutBranchName = outHitBranchname;
  fClustBranchName = outClustBranchname;
  fFolderName = folderName;
}

void PndLmdStripClusterTask::SetBranchNames ( )

virtual

Implements PndSdsTask.

Definition at line 102 of file PndLmdStripClusterTask.cxx.

References PndSdsStripClusterTask::fClustBranchName, PndSdsTask::fFolderName, PndSdsTask::fInBranchName, and PndSdsTask::fOutBranchName.

Referenced by Init().

                                            {
  fInBranchName = "LMDStripDigis";
  fOutBranchName = "LMDHitsStrip";
  fClustBranchName = "LMDStripClusterCand";
  fFolderName = "PndLmd";
}

void PndLmdStripClusterTask::SetCalculators ( )

virtual

Reimplemented from PndSdsStripClusterTask.

Definition at line 161 of file PndLmdStripClusterTask.cxx.

References PndSdsStripClusterTask::fChargeConverter, PndSdsStripClusterTask::fChargeDigiParameterList, PndSdsStripClusterTask::fClusterFinderList, PndSdsStripClusterTask::fDigiParameterList, PndSdsTask::fInBranchId, fVerbose, PndSdsTotDigiPar::GetChargingTime(), PndSdsTotDigiPar::GetClockFrequency(), PndSdsTotDigiPar::GetConstCurrent(), and PndSdsStripClusterTask::SetCalculators().

Referenced by Init().

                                            {
  Info("SetCalculators", "lmd");
  PndSdsStripClusterTask::SetCalculators();
  TIter params(fDigiParameterList);
  TIter totparams(fChargeDigiParameterList);
  while (PndSdsStripDigiPar* digipar = (PndSdsStripDigiPar*)params()) {
    PndSdsTotDigiPar* totdigipar = (PndSdsTotDigiPar*)totparams();
    if (0 == digipar) continue;
    const char* senstype = digipar->GetSensType();
    if (digipar->GetChargeConvMethod() == 1) {
      if (fVerbose > 0)
        Info("SetCalculators()", "Use Tot charge conversion for %s sensors",
             senstype);
      fChargeConverter[senstype] = new PndSdsTotChargeConversion(
          totdigipar->GetChargingTime(), totdigipar->GetConstCurrent(),
          digipar->GetThreshold(), totdigipar->GetClockFrequency(), fVerbose);
    } else {
      if (fVerbose > 0)
        Info("SetCalculators()", "Use Ideal charge conversion for %s sensors",
             senstype);
      fChargeConverter[senstype] = new PndSdsIdealChargeConversion();
    }

    Int_t ClusterMod = digipar->GetClusterMod();
    Int_t RadChannel = digipar->GetRadChannel();
    Int_t RadTime = digipar->GetRadTime();
    if (0 == ClusterMod) {
      fClusterFinderList[senstype] = new PndSdsSimpleStripClusterFinder(
          fInBranchId, RadChannel);  // search radius in channel no.
    } else if (1 == ClusterMod) {
      fClusterFinderList[senstype] =
          new PndSdsStripAdvClusterFinder(fInBranchId, RadChannel, RadTime);
    }
  }

  // TIter alignparams(fAlignParamList);
  // PndLmdAlignPar* lmdalignpar=(PndLmdAlignPar*)alignparams();
  // if(0==lmdalignpar) {
  //   Error("PndLmdStripClusterTask::SetCalculators()","A ALIGN Parameter Set
  //   does not exist properly.");
  // }
  // else{
  //   //   lmdalignpar->Print();
  //   for(int ik=0;ik<32;ik++){
  //     fShiftX[ik] = lmdalignpar->GetShiftX(ik);
  //     fShiftY[ik] = lmdalignpar->GetShiftY(ik);
  //     fShiftZ[ik] = lmdalignpar->GetShiftZ(ik);
  //     fRotateX[ik] = lmdalignpar->GetRotateX(ik);
  //     fRotateY[ik] = lmdalignpar->GetRotateY(ik);
  //     fRotateZ[ik] = lmdalignpar->GetRotateZ(ik);
  //     if (fVerbose > 2) cout<<"fShiftX["<<ik<<"]="<<fShiftX[ik]<<"
  //     fRotateX["<<ik<<"]="<<fRotateX[ik]
  //                        <<" fRotateY["<<ik<<"]="<<fRotateY[ik]<<"
  // fRotateZ["<<ik<<"]="<<fRotateZ[ik]<<endl;
  //   }
  // }
  // lmdalignpar->Print();
}

void PndLmdStripClusterTask::SetClusterType ( )

inline

Definition at line 27 of file PndLmdStripClusterTask.h.

References PndSdsStripClusterTask::fClusterType, and kMVDClusterStrip.

{ fClusterType = kMVDClusterStrip; }

void PndSdsStripClusterTask::SetCurrentCalculators ( PndSdsStripDigiPar *  digipar )

protectedinherited

Definition at line 557 of file PndSdsStripClusterTask.cxx.

References PndSdsStripClusterTask::fChargeAlgos, PndSdsStripClusterTask::fChargeConverter, PndSdsStripClusterTask::fChargeCut, PndSdsStripClusterTask::fClusterFinderList, PndSdsStripClusterTask::fCurrentChargeConverter, PndSdsStripClusterTask::fCurrentClusterfinder, PndSdsStripClusterTask::fCurrentDigiPar, PndSdsStripClusterTask::fCurrentStripCalcBot, PndSdsStripClusterTask::fCurrentStripCalcTop, PndSdsStripClusterTask::fSingleStripChargeThreshold, PndSdsStripClusterTask::fStripCalcBot, PndSdsStripClusterTask::fStripCalcTop, PndSdsStripDigiPar::GetChargeCut(), PndSdsStripDigiPar::GetSensType(), PndSdsStripDigiPar::GetSingleChargeCut(), PndSdsChargeWeightingAlgorithms::SetCalcStrip(), and PndSdsChargeWeightingAlgorithms::SetChargeConverter().

Referenced by Exec(), PndSdsStripClusterTask::Exec(), and PndSdsStripClusterTask::SelectSensorParams().

{
  const char* sensortype = digipar->GetSensType();
  fCurrentStripCalcTop = fStripCalcTop[sensortype];
  fCurrentStripCalcBot = fStripCalcBot[sensortype];
  fCurrentClusterfinder = fClusterFinderList[sensortype];
  fCurrentChargeConverter = fChargeConverter[sensortype];
  fCurrentDigiPar = digipar;
  fChargeAlgos->SetCalcStrip(fCurrentStripCalcTop);
  fChargeAlgos->SetChargeConverter(fCurrentChargeConverter);
  fChargeCut = digipar->GetChargeCut();
  fSingleStripChargeThreshold = digipar->GetSingleChargeCut();
  return;
}

virtual void PndSdsStripClusterTask::SetInBranchId ( )

inlinevirtualinherited

Reimplemented from PndSdsTask.

Definition at line 129 of file PndSdsStripClusterTask.h.

References PndSdsStripClusterTask::fClustBranchName, PndSdsStripClusterTask::fClusterType, PndSdsTask::fInBranchId, and PndSdsTask::fInBranchName.

Referenced by Init(), and PndSdsStripClusterTask::Init().

                                {
                FairRootManager *ioman = FairRootManager::Instance();
                fInBranchId = ioman->GetBranchId(fInBranchName);
                std::cout << "InBranchId: " << fInBranchId << " for Branch: " << fInBranchName.Data() << std::endl;
                fClusterType = ioman->GetBranchId(fClustBranchName);
                std::cout << "fClusterType: " << fClusterType << " for Branch: " << fClustBranchName.Data() << std::endl;

        }

void PndLmdStripClusterTask::SetMSflag ( bool  fflag )

inline

Definition at line 40 of file PndLmdStripClusterTask.h.

References flagMS.

Referenced by runLumi2Reco().

{ flagMS = fflag; };

void PndLmdStripClusterTask::SetParContainers ( )

virtual

Virtual method Init

Reimplemented from PndSdsStripClusterTask.

Definition at line 110 of file PndLmdStripClusterTask.cxx.

References ana, PndSdsStripClusterTask::fChargeDigiParameterList, PndSdsStripClusterTask::fDigiParameterList, PndLmdContFact::GetDigiParNames(), rtdb, PndSdsStripClusterTask::SetParContainers(), and TString.

                                              {
  // called from the FairRun::Init()
  // Caution: The Parameter Set is not filled from the DB IO, yet.
  // This will be done just before this Tasks Init() is called.
  ana = FairRun::Instance();
  rtdb = ana->GetRuntimeDb();

  PndLmdContFact* themvdcontfact =
      (PndLmdContFact*)rtdb->getContFactory("PndLmdContFact");
  TList* theContNames = themvdcontfact->GetDigiParNames();
  Info("SetParContainers()", "The container names list contains %i entries",
       theContNames->GetEntries());
  TIter cfIter(theContNames);
  while (TObjString* contname = (TObjString*)cfIter()) {
    TString parsetname = contname->String();
    Info("SetParContainers()", "%s", parsetname.Data());
    if (parsetname.BeginsWith("SDSStripDigiPar")) {
      PndSdsStripDigiPar* digipar =
          (PndSdsStripDigiPar*)(rtdb->getContainer(parsetname.Data()));
      if (!digipar)
        Fatal("SetParContainers", "No DIGI parameter found: %s",
              parsetname.Data());
      fDigiParameterList->Add(digipar);
    }
    if (parsetname.BeginsWith("SDSStripTotDigiPar")) {
      PndSdsTotDigiPar* totdigipar =
          (PndSdsTotDigiPar*)(rtdb->getContainer(parsetname.Data()));
      if (!totdigipar)
        Fatal("SetParContainers", "No TOT parameter found: %s",
              parsetname.Data());
      fChargeDigiParameterList->Add(totdigipar);
    }
  }  // while

  // //read params for lumi alignment
  // TList* theAlignLMDContNames = themvdcontfact->GetAlignParNames();
  // Info("SetParContainers()","AlignLMD The container names list contains %i
  // entries",theAlignLMDContNames->GetEntries());
  // TIter cfAlIter(theAlignLMDContNames);
  // while (TObjString* contname = (TObjString*)cfAlIter()) {
  //   TString parsetname = contname->String();
  //   Info("SetParContainers()",parsetname.Data());
  //   PndLmdAlignPar *lmdalignpar =
  //   (PndLmdAlignPar*)(rtdb->getContainer(parsetname.Data()));
  //   if(!lmdalignpar) Fatal("SetParContainers","No ALIGN parameter found:
  //   %s",parsetname.Data());
  //   fAlignParamList->Add(lmdalignpar);
  // }
  PndSdsStripClusterTask::SetParContainers();
}

virtual void PndSdsStripClusterTask::SetParContainersMQ ( TList *  )

inlinevirtualinherited

Reimplemented in PndMvdStripClusterTask.

Definition at line 127 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::InitMQ().

{};  //tempList //[R.K.03/2017] unused variable(s)

void PndPersistencyTask::SetPersistency ( Bool_t  val = kTRUE )

inlineinherited

Definition at line 31 of file PndPersistencyTask.h.

References PndPersistencyTask::fPersistency, and val.

Referenced by barrelTrackFinder(), digi_complete(), digi_complete_newSTT(), digiOnly_complete(), PndBarrelTrackFinder::PndBarrelTrackFinder(), PndCATracking::PndCATracking(), PndDrcHitFinder::PndDrcHitFinder(), PndEmc2DLocMaxFinder::PndEmc2DLocMaxFinder(), PndEmcExpClusterSplitter::PndEmcExpClusterSplitter(), PndEmcFullDigiTask::PndEmcFullDigiTask(), PndEmcFWEndcapDigi::PndEmcFWEndcapDigi(), PndEmcFWEndcapTimebasedWaveforms::PndEmcFWEndcapTimebasedWaveforms(), PndEmcHitProducer::PndEmcHitProducer(), PndEmcHitsToWaveform::PndEmcHitsToWaveform(), PndEmcMakeBump::PndEmcMakeBump(), PndEmcMakeCluster::PndEmcMakeCluster(), PndEmcMakeClusterOnline::PndEmcMakeClusterOnline(), PndEmcMakeDigi::PndEmcMakeDigi(), PndEmcMakeRecoHit::PndEmcMakeRecoHit(), PndEmcMultiWaveformToCalibratedDigi::PndEmcMultiWaveformToCalibratedDigi(), PndEmcPhiBumpSplitter::PndEmcPhiBumpSplitter(), PndEmcTmpWaveformToDigi::PndEmcTmpWaveformToDigi(), PndEmcWaveformToCalibratedDigi::PndEmcWaveformToCalibratedDigi(), PndEmcWaveformToDigi::PndEmcWaveformToDigi(), PndFtofHitProducerIdeal::PndFtofHitProducerIdeal(), PndFtsCATracking::PndFtsCATracking(), PndFtsHitProducerIdeal::PndFtsHitProducerIdeal(), PndFtsHitProducerRealFast::PndFtsHitProducerRealFast(), PndFtsHitProducerRealFull::PndFtsHitProducerRealFull(), PndFtsHoughTrackerTask::PndFtsHoughTrackerTask(), PndGemDigitize::PndGemDigitize(), PndGemFindHits::PndGemFindHits(), PndIdealTrackFinder::PndIdealTrackFinder(), PndLmdPixelClusterTask::PndLmdPixelClusterTask(), PndLmdPixelHitProducerFast::PndLmdPixelHitProducerFast(), PndMdtClusterTask::PndMdtClusterTask(), PndMdtDigitization::PndMdtDigitization(), PndMdtHitProducerIdeal::PndMdtHitProducerIdeal(), PndMdtPointsToWaveform::PndMdtPointsToWaveform(), PndMdtTrkProducer::PndMdtTrkProducer(), PndMissingPzCleanerTask::PndMissingPzCleanerTask(), PndMvdGemTrackFinderOnHits::PndMvdGemTrackFinderOnHits(), PndMvdHitProducerIdeal::PndMvdHitProducerIdeal(), PndMvdPixelClusterTask::PndMvdPixelClusterTask(), PndMvdTimeWalkCorrTask::PndMvdTimeWalkCorrTask(), PndMvdToPix4ClusterTask::PndMvdToPix4ClusterTask(), PndRecoKalmanTask::PndRecoKalmanTask(), PndRecoKalmanTask2::PndRecoKalmanTask2(), PndRecoMultiKalmanTask::PndRecoMultiKalmanTask(), PndRecoMultiKalmanTask2::PndRecoMultiKalmanTask2(), PndRichHitFinder::PndRichHitFinder(), PndRichHitProducer::PndRichHitProducer(), PndSciTDigiTask::PndSciTDigiTask(), PndSciTHitProducerIdeal::PndSciTHitProducerIdeal(), PndSdsHitProducerIdeal::PndSdsHitProducerIdeal(), PndSdsHybridHitProducer::PndSdsHybridHitProducer(), PndSdsIdealClusterTask::PndSdsIdealClusterTask(), PndSdsIdealRecoTask::PndSdsIdealRecoTask(), PndSdsNoiseProducer::PndSdsNoiseProducer(), PndSdsPixelClusterTask::PndSdsPixelClusterTask(), PndSdsStripClusterTask::PndSdsStripClusterTask(), PndSdsStripHitProducer::PndSdsStripHitProducer(), PndSdsTimeWalkCorrTask::PndSdsTimeWalkCorrTask(), PndSttFindTracks::PndSttFindTracks(), PndSttHelixHitProducer::PndSttHelixHitProducer(), PndSttHitProducerIdeal::PndSttHitProducerIdeal(), PndSttHitProducerRealFast::PndSttHitProducerRealFast(), PndSttHitProducerRealFull::PndSttHitProducerRealFull(), PndSttMatchTracks::PndSttMatchTracks(), PndSttMvdGemTracking::PndSttMvdGemTracking(), PndTrackSmearTask::PndTrackSmearTask(), PndTrkTracking2::PndTrkTracking2(), reco(), reco_complete(), reco_complete_gf2(), reco_complete_newSTT(), reco_complete_sec(), recoideal_complete(), PndMvdClusterTask::SetPersistance(), PndMvdDigiTask::SetPersistance(), PndLmdPixelHitProducerFast::SetPersistance(), PndSdsHitProducerIdeal::SetPersistance(), PndSttMvdGemTracking::SetPersistenc(), PndMdtClusterTask::SetPersistence(), PndSttHelixHitProducer::SetPersistence(), PndMissingPzCleanerTask::SetPersistence(), PndFtsHitProducerRealFast::SetPersistence(), PndFtsHitProducerRealFull::SetPersistence(), PndSttHitProducerRealFull::SetPersistence(), PndSttHitProducerIdeal::SetPersistence(), PndSttHitProducerRealFast::SetPersistence(), PndFtsHitProducerIdeal::SetPersistence(), PndTrackSmearTask::SetPersistence(), PndSciTHitProducerIdeal::SetPersistence(), PndIdealTrackFinder::SetPersistence(), PndSttMatchTracks::SetPersistence(), PndSttFindTracks::SetPersistence(), PndFtsHoughTrackerTask::SetPersistence(), PndTrkTracking2::SetPersistence(), PndEmcMakeRecoHit::SetStorageOfData(), PndEmcFWEndcapDigi::SetStorageOfData(), PndEmcMakeClusterOnline::SetStorageOfData(), PndEmcFWEndcapTimebasedWaveforms::SetStorageOfData(), PndEmcMakeDigi::SetStorageOfData(), PndMdtPointsToWaveform::SetStorageOfData(), PndEmc2DLocMaxFinder::SetStorageOfData(), PndEmcMakeCluster::SetStorageOfData(), PndEmcHitsToWaveform::SetStorageOfData(), PndEmcMakeBump::SetStorageOfData(), PndEmcTmpWaveformToDigi::SetStorageOfData(), PndEmcWaveformToDigi::SetStorageOfData(), PndEmcWaveformToCalibratedDigi::SetStorageOfData(), PndEmcMultiWaveformToCalibratedDigi::SetStorageOfData(), PndEmcExpClusterSplitter::SetStorageOfData(), PndEmcPhiBumpSplitter::SetStorageOfData(), standard_tracking(), and PndEmcFullDigiTask::StoreDigi().

{ fPersistency = val; }

Member Data Documentation

FairRun* PndLmdStripClusterTask::ana

Definition at line 37 of file PndLmdStripClusterTask.h.

Referenced by SetParContainers().

PndSdsChargeWeightingAlgorithms* PndSdsStripClusterTask::fChargeAlgos

protectedinherited

Definition at line 188 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::CalcMeanCharge(), PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::FillClusterFinders(), PndSdsStripClusterTask::operator=(), PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetCurrentCalculators().

std::map<const char*,PndSdsChargeConversion*> PndSdsStripClusterTask::fChargeConverter

protectedinherited

Definition at line 184 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::operator=(), SetCalculators(), PndMvdStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetCurrentCalculators().

Double_t PndSdsStripClusterTask::fChargeCut

protectedinherited

Definition at line 170 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

TList* PndSdsStripClusterTask::fChargeDigiParameterList

protectedinherited

Definition at line 180 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=(), SetCalculators(), PndMvdStripClusterTask::SetCalculators(), SetParContainers(), PndMvdStripClusterTask::SetParContainers(), PndMvdStripClusterTask::SetParContainersMQ(), and PndSdsStripClusterTask::~PndSdsStripClusterTask().

TString PndSdsStripClusterTask::fClustBranchName

protectedinherited

Definition at line 158 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), Init(), PndSdsStripClusterTask::Init(), PndSdsStripClusterTask::operator=(), SetBranchNames(), PndMvdStripClusterTask::SetBranchNames(), and PndSdsStripClusterTask::SetInBranchId().

TClonesArray* PndSdsStripClusterTask::fClusterArray

protectedinherited

Definition at line 155 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::ExecMQ(), Init(), PndSdsStripClusterTask::Init(), PndSdsStripClusterTask::InitMQ(), and PndSdsStripClusterTask::operator=().

std::map<const char*,PndSdsStripClusterer*> PndSdsStripClusterTask::fClusterFinderList

protectedinherited

Definition at line 195 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::operator=(), PndSdsStripClusterTask::ResetClusterFinders(), SetCalculators(), PndMvdStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetCurrentCalculators().

Int_t PndSdsStripClusterTask::fClusterType

protectedinherited

Definition at line 159 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::operator=(), SetClusterType(), and PndSdsStripClusterTask::SetInBranchId().

PndSdsChargeConversion* PndSdsStripClusterTask::fCurrentChargeConverter

protectedinherited

Definition at line 189 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::CalcMeanCharge(), PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

PndSdsStripClusterer* PndSdsStripClusterTask::fCurrentClusterfinder

protectedinherited

Geometry name handling.

Definition at line 194 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ClearCalculators(), Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::FillClusterFinders(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

PndSdsStripDigiPar* PndSdsStripClusterTask::fCurrentDigiPar

protectedinherited

Definition at line 178 of file PndSdsStripClusterTask.h.

Referenced by Backmap(), PndSdsStripClusterTask::Backmap(), PndSdsStripClusterTask::CalcMeanCharge(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

PndSdsCalcStrip* PndSdsStripClusterTask::fCurrentStripCalcBot

protectedinherited

Definition at line 187 of file PndSdsStripClusterTask.h.

Referenced by Backmap(), PndSdsStripClusterTask::Backmap(), PndSdsStripClusterTask::ClearCalculators(), Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

PndSdsCalcStrip* PndSdsStripClusterTask::fCurrentStripCalcTop

protectedinherited

Definition at line 186 of file PndSdsStripClusterTask.h.

Referenced by Backmap(), PndSdsStripClusterTask::Backmap(), PndSdsStripClusterTask::ClearCalculators(), Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::FillClusterFinders(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

TClonesArray* PndSdsStripClusterTask::fDigiArray

protectedinherited

Definition at line 154 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::CalcMeanCharge(), Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::ExecMQ(), PndSdsStripClusterTask::FillClusterFinders(), Init(), PndSdsStripClusterTask::Init(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCalculators().

PndSdsStripDigiPar* PndSdsStripClusterTask::fDigiPar

protectedinherited

Definition at line 190 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=().

TList* PndSdsStripClusterTask::fDigiParameterList

protectedinherited

Digitization Parameters.

Definition at line 177 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::operator=(), PndSdsStripClusterTask::SelectSensorParams(), SetCalculators(), PndMvdStripClusterTask::SetCalculators(), PndSdsStripClusterTask::SetCalculators(), SetParContainers(), PndMvdStripClusterTask::SetParContainers(), PndMvdStripClusterTask::SetParContainersMQ(), and PndSdsStripClusterTask::~PndSdsStripClusterTask().

FairEventHeader* PndSdsStripClusterTask::fEventHeader

protectedinherited

Definition at line 174 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ExecMQ(), and PndSdsStripClusterTask::operator=().

Int_t PndSdsStripClusterTask::fFEcolumns

protectedinherited

Definition at line 168 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=().

Int_t PndSdsStripClusterTask::fFErows

protectedinherited

Definition at line 169 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=().

TString PndSdsTask::fFolderName

protectedinherited

Definition at line 41 of file PndSdsTask.h.

Referenced by PndLmdPixelClusterTask::Init(), Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndSdsRecoTask::Init(), PndSdsHitProducerIdeal::Init(), PndLmdPairFinderTask::Init(), PndSdsNoiseProducer::Init(), PndSdsHybridHitProducer::Init(), PndSdsIdealRecoTask::Init(), PndSdsIdealClusterTask::Init(), PndSdsStripHitProducer::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndLmdIdealClusterTask::SetBranchNames(), PndMvdTimeWalkCorrTask::SetBranchNames(), SetBranchNames(), PndMvdStripClusterTask::SetBranchNames(), PndLmdStripHitProducer::SetBranchNames(), PndMvdIdealClusterTask::SetBranchNames(), PndMvdHitProducerIdeal::SetBranchNames(), PndLmdPixelClusterTask::SetBranchNames(), PndMvdHybridHitProducer::SetBranchNames(), PndLmdHybridHitProducer::SetBranchNames(), PndMvdPixelClusterTask::SetBranchNames(), PndLmdIdealRecoTask::SetBranchNames(), PndLmdHitProducerIdeal::SetBranchNames(), PndLmdPixelHitProducerFast::SetBranchNames(), and PndMvdStripHitProducer::SetBranchNames().

BinaryFunctor* PndSdsStripClusterTask::fFunctor

protectedinherited

Definition at line 197 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), Init(), PndSdsStripClusterTask::Init(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::~PndSdsStripClusterTask().

PndGeoHandling* PndLmdStripClusterTask::fGeoH

Definition at line 36 of file PndLmdStripClusterTask.h.

Referenced by Backmap(), Exec(), and PndLmdStripClusterTask().

TClonesArray* PndSdsStripClusterTask::fHitArray

protectedinherited

Definition at line 156 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::ExecMQ(), Init(), PndSdsStripClusterTask::Init(), PndSdsStripClusterTask::InitMQ(), and PndSdsStripClusterTask::operator=().

Int_t PndSdsTask::fInBranchId

protectedinherited

Definition at line 43 of file PndSdsTask.h.

Referenced by PndSdsStripHitProducer::AddDigi(), PndLmdPixelClusterTask::Exec(), PndLmdPixelHitProducerFast::Exec(), PndSdsHitProducerIdeal::Exec(), PndSdsHybridHitProducer::Exec(), PndSdsPixelClusterTask::Exec(), SetCalculators(), PndMvdStripClusterTask::SetCalculators(), PndSdsTask::SetInBranchId(), PndSdsIdealClusterTask::SetInBranchId(), PndSdsPixelClusterTask::SetInBranchId(), and PndSdsStripClusterTask::SetInBranchId().

TString PndSdsTask::fInBranchName

protectedinherited

Definition at line 39 of file PndSdsTask.h.

Referenced by PndSdsStripHitProducer::AddDigi(), PndLmdPixelClusterTask::Exec(), Exec(), PndSdsStripHitProducer::Exec(), PndSdsPixelClusterTask::Exec(), PndSdsStripClusterTask::Exec(), PndLmdPixelClusterTask::Init(), Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndSdsHitProducerIdeal::Init(), PndLmdPairFinderTask::Init(), PndSdsHybridHitProducer::Init(), PndSdsIdealRecoTask::Init(), PndSdsIdealClusterTask::Init(), PndSdsStripHitProducer::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndMvdHitProducerIdeal::PndMvdHitProducerIdeal(), PndLmdIdealClusterTask::SetBranchNames(), PndMvdTimeWalkCorrTask::SetBranchNames(), SetBranchNames(), PndMvdStripClusterTask::SetBranchNames(), PndLmdStripHitProducer::SetBranchNames(), PndMvdHitProducerIdeal::SetBranchNames(), PndMvdIdealClusterTask::SetBranchNames(), PndLmdPixelClusterTask::SetBranchNames(), PndLmdHybridHitProducer::SetBranchNames(), PndMvdHybridHitProducer::SetBranchNames(), PndMvdPixelClusterTask::SetBranchNames(), PndLmdIdealRecoTask::SetBranchNames(), PndLmdHitProducerIdeal::SetBranchNames(), PndLmdPixelHitProducerFast::SetBranchNames(), PndLmdPairFinderTask::SetBranchNames(), PndMvdStripHitProducer::SetBranchNames(), PndSdsTask::SetInBranchId(), PndSdsIdealClusterTask::SetInBranchId(), PndSdsPixelClusterTask::SetInBranchId(), and PndSdsStripClusterTask::SetInBranchId().

bool PndLmdStripClusterTask::flagMS

private

Definition at line 44 of file PndLmdStripClusterTask.h.

Referenced by Backmap(), PndLmdStripClusterTask(), and SetMSflag().

Int_t PndSdsTask::fOutBranchId

protectedinherited

Definition at line 44 of file PndSdsTask.h.

Referenced by PndSdsTask::SetInBranchId().

TString PndSdsTask::fOutBranchName

protectedinherited

Definition at line 40 of file PndSdsTask.h.

Referenced by PndLmdPixelClusterTask::Exec(), Exec(), PndSdsStripHitProducer::Exec(), PndLmdPixelClusterTask::Init(), Init(), PndSdsTimeWalkCorrTask::Init(), PndLmdPixelHitProducerFast::Init(), PndSdsRecoTask::Init(), PndSdsHitProducerIdeal::Init(), PndLmdPairFinderTask::Init(), PndSdsHybridHitProducer::Init(), PndSdsIdealRecoTask::Init(), PndSdsIdealClusterTask::Init(), PndSdsStripHitProducer::Init(), PndSdsPixelClusterTask::Init(), PndSdsStripClusterTask::Init(), PndLmdIdealClusterTask::SetBranchNames(), PndMvdTimeWalkCorrTask::SetBranchNames(), SetBranchNames(), PndMvdStripClusterTask::SetBranchNames(), PndLmdStripHitProducer::SetBranchNames(), PndMvdIdealClusterTask::SetBranchNames(), PndLmdPixelClusterTask::SetBranchNames(), PndMvdHitProducerIdeal::SetBranchNames(), PndLmdHybridHitProducer::SetBranchNames(), PndMvdHybridHitProducer::SetBranchNames(), PndMvdPixelClusterTask::SetBranchNames(), PndLmdIdealRecoTask::SetBranchNames(), PndLmdHitProducerIdeal::SetBranchNames(), PndLmdPixelHitProducerFast::SetBranchNames(), PndMvdStripHitProducer::SetBranchNames(), and PndSdsTask::SetInBranchId().

TString PndSdsStripClusterTask::fPath

protectedinherited

Definition at line 145 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::Init(), and PndSdsStripClusterTask::operator=().

Double_t PndLmdStripClusterTask::fPbeam

private

Definition at line 46 of file PndLmdStripClusterTask.h.

Referenced by AddMSErr(), and Init().

Int_t PndSdsStripClusterTask::fRadChannel

protectedinherited

Definition at line 171 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=().

Int_t PndSdsStripClusterTask::fRadTime

protectedinherited

Definition at line 172 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::operator=().

PndSensorNamePar* PndSdsStripClusterTask::fSensorNamePar

protectedinherited

Definition at line 179 of file PndSdsStripClusterTask.h.

Referenced by PndMvdStripClusterTask::GetParList(), PndSdsStripClusterTask::InitMQ(), and PndSdsStripClusterTask::operator=().

Double_t PndSdsStripClusterTask::fSingleStripChargeThreshold

protectedinherited

Definition at line 173 of file PndSdsStripClusterTask.h.

Referenced by Exec(), PndSdsStripClusterTask::Exec(), PndSdsStripClusterTask::operator=(), and PndSdsStripClusterTask::SetCurrentCalculators().

std::map<const char*,PndSdsCalcStrip*> PndSdsStripClusterTask::fStripCalcBot

protectedinherited

Definition at line 183 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::operator=(), PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetCurrentCalculators().

std::map<const char*,PndSdsCalcStrip*> PndSdsStripClusterTask::fStripCalcTop

protectedinherited

Calculator objects.

Definition at line 182 of file PndSdsStripClusterTask.h.

Referenced by PndSdsStripClusterTask::ClearCalculators(), PndSdsStripClusterTask::operator=(), PndSdsStripClusterTask::SetCalculators(), and PndSdsStripClusterTask::SetCurrentCalculators().

FairRuntimeDb* PndLmdStripClusterTask::rtdb

Definition at line 38 of file PndLmdStripClusterTask.h.

Referenced by Init(), and SetParContainers().

---

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

• PndLmdStripClusterTask.h
• PndLmdStripClusterTask.cxx