PndSdsChargedWeightedPixelMapping: Gets a vector of DigiHits and calculates the cluster center weighted with the charge params: Number of columns in FE, Number of rows in FE, Pixel dimension in x, Pixel dimension in y params are taken from parameter database. More...

#include <PndSdsChargeWeightedPixelMapping.h>

Inheritance diagram for PndSdsChargeWeightedPixelMapping:

Public Member Functions
	PndSdsChargeWeightedPixelMapping ()

	PndSdsChargeWeightedPixelMapping (const PndSdsChargeWeightedPixelMapping &other)

	PndSdsChargeWeightedPixelMapping (PndGeoHandling *geo)

virtual	~PndSdsChargeWeightedPixelMapping ()

PndSdsChargeWeightedPixelMapping &	operator= (PndSdsChargeWeightedPixelMapping &other)

PndSdsHit	GetCluster (std::vector< PndSdsDigiPixel > pixelArray)
	Main function of class to calculate the PndSdsHit out of the given PndSdsDigis. More...

void	SetVerbose (Int_t level)

Public Attributes
std::vector< PndSdsDigiPixel >	fDigiArray

PndGeoHandling *	fGeoH

Int_t	fVerbose

Protected Attributes
PndSdsChargeConversion *	fChargeConverter

Double_t	flx

Double_t	fly

Int_t	fcols

Int_t	frows

Private Member Functions
TGeoHMatrix	GetTransformation (Int_t sensorID)

TVector3	GetSensorDimensions (Int_t sensorID)

Detailed Description

PndSdsChargedWeightedPixelMapping: Gets a vector of DigiHits and calculates the cluster center weighted with the charge params: Number of columns in FE, Number of rows in FE, Pixel dimension in x, Pixel dimension in y params are taken from parameter database.

PndSdsChargeWeightedPixelMapping.h

Author: T.Stockmanns t.sto.nosp@m.ckma.nosp@m.nns@f.nosp@m.z-ju.nosp@m.elich.nosp@m..de

Definition at line 15 of file PndSdsChargeWeightedPixelMapping.h.

Constructor & Destructor Documentation

PndSdsChargeWeightedPixelMapping::PndSdsChargeWeightedPixelMapping ( )

Definition at line 7 of file PndSdsChargeWeightedPixelMapping.cxx.

 :PndSdsPixelBackMapping(),
       fChargeConverter(NULL),
       flx(0.),
       fly(0.),
       fcols(0),
       frows(0)
 {}

PndSdsChargeWeightedPixelMapping::PndSdsChargeWeightedPixelMapping ( const PndSdsChargeWeightedPixelMapping & other )

inline

Definition at line 19 of file PndSdsChargeWeightedPixelMapping.h.

                                                                                     :
       PndSdsPixelBackMapping(other),
       fChargeConverter(other.fChargeConverter),
       flx(other.flx),
       fly(other.fly),
       fcols(other.fcols),
       frows(other.frows)
     {};

PndSdsChargeWeightedPixelMapping::PndSdsChargeWeightedPixelMapping ( PndGeoHandling * geo )

Definition at line 15 of file PndSdsChargeWeightedPixelMapping.cxx.

 :PndSdsPixelBackMapping(geo),
       fChargeConverter(NULL),
       flx(0.),
       fly(0.),
       fcols(0),
       frows(0)
 {}

virtual PndSdsChargeWeightedPixelMapping::~PndSdsChargeWeightedPixelMapping ( )

inlinevirtual

Definition at line 28 of file PndSdsChargeWeightedPixelMapping.h.

28 {};

Member Function Documentation

PndSdsHit PndSdsChargeWeightedPixelMapping::GetCluster ( std::vector< PndSdsDigiPixel > pixelArray )

virtual

Main function of class to calculate the PndSdsHit out of the given PndSdsDigis.

Implements PndSdsPixelBackMapping.

Definition at line 24 of file PndSdsChargeWeightedPixelMapping.cxx.

References col, count, PndSdsChargeConversion::DigiValueToCharge(), Double_t, fChargeConverter, fcols, PndSdsPixelBackMapping::fDigiArray, PndSdsPixelBackMapping::fGeoH, flx, fly, frows, PndSdsPixelBackMapping::fVerbose, GetSensorDimensions(), PndGeoHandling::GetSensorDimensionsShortId(), i, PndGeoHandling::LocalToMasterErrorsShortId(), PndGeoHandling::LocalToMasterShortId(), offset(), pos, row, PndSdsHit::SetCov(), sqrt(), and t.

Referenced by PndSdsIdealClusterTask::Exec().

 {
 fDigiArray = pixelArray;
         Double_t col = 0, row = 0, charge = 0;
         Double_t tempCol = 0, tempRow = 0;
         std::vector<Double_t> timeValues;
         std::vector<Double_t> timeValueErrors;
 
         Int_t count = 0, mcindex=-1;
         //Double_t local[2], master[2];
   //TODO: Get away from default 10 Frontends per column?
 
         if (fDigiArray.size() == 1){
                 if (fChargeConverter->DigiValueToCharge(fDigiArray[0]) > 0){
                         col = fDigiArray[0].GetPixelColumn() + ((Int_t)(fDigiArray[0].GetFE()%10)) * fcols;
                         if (col < 0){
                                 col -= 0.5;
                                 col += frows / 2;
                         }
                         else col += 0.5;
                         row = fDigiArray[0].GetPixelRow()+ (fDigiArray[0].GetFE()/10) * frows;
                         if (row < 0){
                                 row -= 0.5;
                                 row += flx /2;
                         }
                         else row += 0.5;
                         if (fVerbose > 1)
                                 std::cout << "GetCluster:col/row " << col << " " << row << std::endl;
                         count = 1;
                         charge = fChargeConverter->DigiValueToCharge(fDigiArray[0]);
                           for(Int_t mcI = 0; mcI<fDigiArray[0].GetNIndices();mcI++){
                                 if (fDigiArray[0].GetIndex(mcI) > -1) {
                                   mcindex = fDigiArray[0].GetIndex(mcI);
                                   break;
                                 }
                           }
                           timeValues.push_back(fDigiArray[0].GetTimeStamp());
                           timeValueErrors.push_back(fDigiArray[0].GetTimeStampError());
                 }
         }
         else {
                 //cout << "Multiple Hits!" << std::endl;
                 for (UInt_t i = 0; i < fDigiArray.size(); i++){
                         //cout << "ActCol / Row" << col << " " << row << " added Col/Row " << fDigiArray[i].GetPixelColumn() << " " << fDigiArray[i].GetPixelRow() << endl;
                         if (fChargeConverter->DigiValueToCharge(fDigiArray[i]) > 0){
                                 tempCol = fDigiArray[i].GetPixelColumn() + (Int_t)(fDigiArray[0].GetFE()%10) * fcols;
                                 tempRow = fDigiArray[i].GetPixelRow() + fDigiArray[0].GetFE()/10 * frows;
                                 col += (tempCol*fChargeConverter->DigiValueToCharge(fDigiArray[i]));
                                 row += (tempRow*fChargeConverter->DigiValueToCharge(fDigiArray[i]));
                                 charge += fChargeConverter->DigiValueToCharge(fDigiArray[i]);
                                 timeValues.push_back(fDigiArray[i].GetTimeStamp());
                                 timeValueErrors.push_back(fDigiArray[i].GetTimeStampError());
                                 count++;
         if(mcindex < 0){
           for(Int_t mcI = 0; mcI<fDigiArray[i].GetNIndices();mcI++){ 
             if (fDigiArray[i].GetIndex(mcI) > -1) {
               mcindex = fDigiArray[i].GetIndex(mcI);
               break;
             }
           }
         }//mcindex
         
                         }
                 }
                 if (count > 0){
                         if (charge > 0){
                                 col /= charge;
                                 row /= charge;
                         }
                         col += 0.5;
                         row += 0.5;
                 }
                 else col = row = 0;
         }
         if (fVerbose > 1){
                 std::cout << "Col: " << col << " Row: " << row << std::endl;
         }
 
   TVector3 offset = GetSensorDimensions(fDigiArray[0].GetSensorID());
   TVector3 locpos( col*flx - offset.X(), row*fly - offset.Y(), 0);
   TVector3 pos = fGeoH->LocalToMasterShortId(locpos,fDigiArray[0].GetSensorID());
 
   Double_t errZ = 2.*fGeoH->GetSensorDimensionsShortId(fDigiArray[0].GetSensorID()).Z();
   TMatrixD locCov(3,3);
   locCov[0][0]=flx*flx/12.;
   locCov[1][1]=fly*fly/12.;
   locCov[2][2]=errZ*errZ/12;
   TMatrixD hitCov=fGeoH->LocalToMasterErrorsShortId(locCov,fDigiArray[0].GetSensorID());
   TVector3 dpos(sqrt(hitCov[0][0]),sqrt(hitCov[1][1]),sqrt(hitCov[2][2]));
  //std::cout << "-I- PndSdsChargeWeightedPixelMapping Error DPos: " << dpos.x() << " " << dpos.y() << " " << dpos.z() << std::endl;
 
   Double_t meanTime = 0;
   //Double_t meanTimeError = 0;
   Double_t sumVar = 0;
 
   for (UInt_t t = 0; t < timeValues.size(); t++){
           meanTime += timeValues[t] / (timeValueErrors[t] * timeValueErrors[t]);
           sumVar += 1/(timeValueErrors[t] * timeValueErrors[t]);
   }
 
   if (sumVar > 0)
           meanTime /= sumVar;
 
 
 
   PndSdsHit thehit(fDigiArray[0].GetDetID(),fDigiArray[0].GetSensorID(), pos, dpos, -1, charge, fDigiArray.size(),mcindex);
   thehit.SetCov(hitCov);
   thehit.SetTimeStamp(meanTime);
   thehit.SetTimeStampError(1/sumVar);
   //std::cout << "-I- PndSdsChargeWeightedPixelMapping TimeStamp: " << tempTime/count << std::endl;
   return thehit;
 }

TVector3 PndSdsChargeWeightedPixelMapping::GetSensorDimensions ( Int_t sensorID )

private

Definition at line 146 of file PndSdsChargeWeightedPixelMapping.cxx.

References PndSdsPixelBackMapping::fGeoH, PndGeoHandling::GetPath(), and gGeoManager.

Referenced by GetCluster().

 {
         gGeoManager->cd(fGeoH->GetPath(sensorID));
         TGeoVolume* actVolume = gGeoManager->GetCurrentVolume();
         TGeoBBox* actBox = (TGeoBBox*)(actVolume->GetShape());
         TVector3 result;
         result.SetX(actBox->GetDX());
         result.SetY(actBox->GetDY());
         result.SetZ(actBox->GetDZ());
 
         //result.Dump();
 
         return result;
 }

TGeoHMatrix PndSdsChargeWeightedPixelMapping::GetTransformation ( Int_t sensorID )

private

Definition at line 137 of file PndSdsChargeWeightedPixelMapping.cxx.

References PndSdsPixelBackMapping::fGeoH, PndSdsPixelBackMapping::fVerbose, PndGeoHandling::GetPath(), and gGeoManager.

 {
   gGeoManager->cd(fGeoH->GetPath(sensorID));
   TGeoHMatrix* transMat = gGeoManager->GetCurrentMatrix();
   if (fVerbose > 2)
         transMat->Print("");
   return *transMat;
 }

PndSdsChargeWeightedPixelMapping& PndSdsChargeWeightedPixelMapping::operator= ( PndSdsChargeWeightedPixelMapping & other )

inline

Definition at line 29 of file PndSdsChargeWeightedPixelMapping.h.

References fChargeConverter, fcols, flx, fly, and frows.

     {
       fChargeConverter=other.fChargeConverter;
       flx=other.flx;
       fly=other.fly;
       fcols=other.fcols;
       frows=other.frows;
      return *this;
    };