AngClusterAna Class Reference

#include <AngClusterAna.h>

Inheritance diagram for AngClusterAna:

NueAnaBase List of all members.

Public Types

typedef std::deque< Int_t > DeqInt_t
typedef DeqInt_t::iterator IterDeqInt_t
typedef DeqInt_t::size_type SizeDeqInt_t
typedef std::deque< Float_t > DeqFloat_t
typedef DeqFloat_t::iterator IterDeqFloat_t
typedef std::vector< Int_t > VecInt_t
typedef VecInt_t::iterator IterVecInt_t
typedef std::vector< Float_t > VecFloat_t
typedef VecFloat_t::iterator IterVecFloat_t
typedef std::deque< std::deque<
Int_t > > 
DeqDeqInt_t
typedef DeqDeqInt_t::iterator IterDeqDeqInt_t
typedef DeqDeqInt_t::size_type SizeDeqDeqInt_t
typedef std::deque< TMatrixD > DeqTMatrixD
typedef DeqTMatrixD::iterator IterDeqTMatrixD

Public Member Functions

 AngClusterAna (AngCluster &ac)
 ~AngClusterAna ()
void Set3DHit (DeqFloat_t &x, DeqFloat_t &y, DeqFloat_t &z, DeqFloat_t &e)
void Analyze (int evtn, RecRecordImp< RecCandHeader > *srobj)
void WeightedEnergy (int evtn, RecRecordImp< RecCandHeader > *srobj)
void Reset ()
void GetAngCluster (Int_t &primShow, DeqDeqInt_t &clusterMap, TVector3 &primDir)

Public Attributes

VecInt_t fClusterID
DeqInt_t fClusterSize
Int_t fNCluster
Int_t fPrimShow
DeqDeqInt_t fClusterMap
TVector3 fPrimDir
Float_t fTotalEventHitEnergy

Private Member Functions

 AngClusterAna (const AngClusterAna &rhs)
AngClusterAnaoperator= (const AngClusterAna &rhs)
void FindCluster ()
void ClusterVarCalc ()
void FindCentroidBlob (TMatrixD &grid, const Int_t nBinX, const Int_t nBinY, Int_t indX, Int_t indY, TMatrixD &blobCentro)

Private Attributes

AngClusterfAngCluster
DeqFloat_t centroidX
DeqFloat_t centroidY
DeqFloat_t fX
DeqFloat_t fY
DeqFloat_t fZ
DeqFloat_t fE

Detailed Description

Definition at line 29 of file AngClusterAna.h.


Member Typedef Documentation

typedef std::deque< std::deque <Int_t> > AngClusterAna::DeqDeqInt_t

Definition at line 48 of file AngClusterAna.h.

typedef std::deque<Float_t> AngClusterAna::DeqFloat_t

Definition at line 39 of file AngClusterAna.h.

typedef std::deque<Int_t> AngClusterAna::DeqInt_t

Definition at line 35 of file AngClusterAna.h.

typedef std::deque<TMatrixD> AngClusterAna::DeqTMatrixD

Definition at line 52 of file AngClusterAna.h.

typedef DeqDeqInt_t::iterator AngClusterAna::IterDeqDeqInt_t

Definition at line 49 of file AngClusterAna.h.

typedef DeqFloat_t::iterator AngClusterAna::IterDeqFloat_t

Definition at line 40 of file AngClusterAna.h.

typedef DeqInt_t::iterator AngClusterAna::IterDeqInt_t

Definition at line 36 of file AngClusterAna.h.

typedef DeqTMatrixD::iterator AngClusterAna::IterDeqTMatrixD

Definition at line 53 of file AngClusterAna.h.

typedef VecFloat_t::iterator AngClusterAna::IterVecFloat_t

Definition at line 46 of file AngClusterAna.h.

typedef VecInt_t::iterator AngClusterAna::IterVecInt_t

Definition at line 43 of file AngClusterAna.h.

typedef DeqDeqInt_t::size_type AngClusterAna::SizeDeqDeqInt_t

Definition at line 50 of file AngClusterAna.h.

typedef DeqInt_t::size_type AngClusterAna::SizeDeqInt_t

Definition at line 37 of file AngClusterAna.h.

typedef std::vector<Float_t> AngClusterAna::VecFloat_t

Definition at line 45 of file AngClusterAna.h.

typedef std::vector<Int_t> AngClusterAna::VecInt_t

Definition at line 42 of file AngClusterAna.h.


Constructor & Destructor Documentation

AngClusterAna::AngClusterAna ( AngCluster ac  ) 

Definition at line 47 of file AngClusterAna.cxx.

00047                                           :
00048     fAngCluster(ac)
00049 {
00050 
00051 
00052 }

AngClusterAna::~AngClusterAna (  ) 

Definition at line 54 of file AngClusterAna.cxx.

00055 {
00056 
00057 }

AngClusterAna::AngClusterAna ( const AngClusterAna rhs  )  [private]


Member Function Documentation

void AngClusterAna::Analyze ( int  evtn,
RecRecordImp< RecCandHeader > *  srobj 
) [virtual]

Implements NueAnaBase.

Definition at line 59 of file AngClusterAna.cxx.

References ClusterVarCalc(), FindCluster(), fZ, RecRecordImp< T >::GetHeader(), RecPhysicsHeader::GetSnarl(), Msg::kDebug, Msg::kInfo, MSG, and WeightedEnergy().

Referenced by NueRecordAna::Analyze(), and NueDisplayModule::Analyze().

00061 {
00062 
00063     MSG("AngClusterAna",Msg::kInfo)<<"In AngClusterAna::Analyze"<<endl;
00064     MSG("AngClusterAna",Msg::kDebug)<<"On Snarl "<<srobj->GetHeader().GetSnarl()
00065                                  <<" event "<<evtn<<endl;
00066 
00067     if(srobj==0){
00068         return;
00069     }
00070     if(((dynamic_cast<NtpStRecord *>(srobj))==0)&&
00071        ((dynamic_cast<NtpSRRecord *>(srobj))==0)){
00072         return;
00073     }
00074 
00075 
00076     if(fZ.size() >=3 && fZ.size() <= 1000){
00077 
00078         //Find Clusters
00079         FindCluster();
00080 
00081         //Calculate cluster variables and fill branch.
00082         ClusterVarCalc();
00083     }
00084 
00085     WeightedEnergy(evtn, srobj);
00086 }

void AngClusterAna::ClusterVarCalc (  )  [private]

Definition at line 674 of file AngClusterAna.cxx.

References centroidX, centroidY, AngCluster::fACluPrimEnergy, AngCluster::fACluPrimEnergyRatio, AngCluster::fACluRmsShwAxis, AngCluster::fACluRmsZAxis, AngCluster::fACluShwDirX, AngCluster::fACluShwDirY, AngCluster::fACluShwDirZ, fAngCluster, fClusterMap, fClusterSize, fE, fPrimDir, fPrimShow, fTotalEventHitEnergy, fX, fY, fZ, ANtpDefaultValue::IsDefault(), Msg::kDebug, Msg::kInfo, kMeuToGeV, MSG, and AngCluster::Reset().

Referenced by Analyze().

00675 {
00676     if (ANtpDefVal::IsDefault(fPrimShow)){
00677 
00678         MSG("AngClusterAna",Msg::kInfo)<< "No primary cluster "
00679                                        << " found in event."
00680                                        << endl << endl;
00681         fAngCluster.Reset();
00682         return;
00683     }
00684 
00685     //Get primary cluster centroid coordinates
00686     Float_t cosXCent=centroidX.at(fPrimShow);
00687     Float_t cosYCent=centroidY.at(fPrimShow);
00688 
00689     Float_t temp = 1.0-(cosXCent*cosXCent)-(cosYCent*cosYCent);
00690     if(temp < 0) temp = 0;
00691     Float_t cosZCent =TMath::Sqrt(temp);
00692 
00693     //Define histograms
00694     Int_t zBin =21;
00695     Int_t rBin =21;
00696     Float_t zMin =-0.05;
00697     Float_t rMin =-0.05;
00698     Float_t zMax =1.05;
00699     Float_t rMax =1.05;
00700 
00701     TH2F *hRZPrime;
00702     hRZPrime = new TH2F("RZPrime","r vs zprime"
00703                         , zBin, zMin, zMax
00704                         , rBin, rMin, rMax);
00705 
00706     TH2F *hRZ;
00707     hRZ = new TH2F("RZ","r vs z"
00708                    ,zBin, zMin, zMax
00709                    ,rBin, rMin, rMax);
00710 
00711     TH1F *hZPrime;
00712     hZPrime = new TH1F("ZPrime","ELongPrime"
00713                      ,zBin, zMin, zMax);
00714     
00715     TH1F *hRPrime;
00716     hRPrime = new TH1F("RPrime","ETransPrime"
00717                        ,rBin, rMin, rMax);
00718     
00719     TH1F *hZAxis;
00720     hZAxis = new TH1F("ZAxis","ELong"
00721                     ,zBin, zMin, zMax);
00722     
00723     TH1F *hRAxis;
00724     hRAxis = new TH1F("RAxis","ETrans"
00725                       ,rBin, rMin, rMax);
00726 
00727     
00728     //Iterate over all hits in primary cluster and 
00729     //calculate XYZ position centroid
00730     Float_t zPrime;
00731     Float_t distVertexSq;
00732 
00733     Float_t rPrime;
00734     Float_t rAxis;
00735 
00736     Float_t centroX=0;
00737     Float_t centroY=0;
00738     Float_t centroZ=0;
00739 
00740     //Needed to calculate cluster centroid weighted by distance to vertex.
00741     Float_t centroWeightX=0;
00742     Float_t centroWeightY=0;
00743     Float_t centroWeightZ=0;
00744 
00745     Float_t  totalHitEnergy=0.0;
00746 
00747     Float_t epsilon=0.0000001;
00748 
00749     DeqDeqInt_t cluTemp; 
00750     cluTemp.push_back(fClusterMap.at(fPrimShow)); //Select the 
00751                                                   //primary cluster
00752   
00753     for (IterDeqDeqInt_t cluIter = cluTemp.begin()
00754              ;cluIter != cluTemp.end()
00755              ; ++cluIter ){
00756         for (IterDeqInt_t hitIter =  cluIter->begin()
00757                  ;hitIter < cluIter->end()
00758                  ; ++hitIter){
00759             
00760             zPrime=fX.at(*hitIter)*cosXCent
00761                 +fY.at(*hitIter)*cosYCent
00762                 +fZ.at(*hitIter)*cosZCent;
00763             
00764             distVertexSq=fX.at(*hitIter)*fX.at(*hitIter)
00765                 +fY.at(*hitIter)*fY.at(*hitIter)
00766                 +fZ.at(*hitIter)*fZ.at(*hitIter);
00767             
00768             rPrime=TMath::Sqrt(
00769                 TMath::Abs(distVertexSq-(zPrime*zPrime)));
00770             
00771             rAxis=TMath::Sqrt(
00772                 TMath::Abs(distVertexSq-fZ.at(*hitIter)*fZ.at(*hitIter)));
00773 
00774             hRZPrime->Fill(zPrime,rPrime,fE.at(*hitIter));
00775             hRZ     ->Fill(fZ.at(*hitIter),rAxis,fE.at(*hitIter));
00776          
00777             hZPrime ->Fill(zPrime,fE.at(*hitIter));
00778             hRPrime ->Fill(rPrime,fE.at(*hitIter));
00779 
00780             hZAxis  ->Fill(fZ.at(*hitIter),fE.at(*hitIter));
00781             hRAxis  ->Fill(rAxis,fE.at(*hitIter));
00782 
00783             centroX+=fX.at(*hitIter);
00784             centroY+=fY.at(*hitIter);
00785             centroZ+=fZ.at(*hitIter);
00786 
00787             //Total Energy of primary cluster
00788             totalHitEnergy+=(fE.at(*hitIter))*kMeuToGeV;
00789 
00790             MSG("AngClusterAna",Msg::kDebug)<< "(X,Y,Z) = " << "(" 
00791                                             << fX.at(*hitIter) << ","
00792                                             << fY.at(*hitIter) << ","
00793                                             << fZ.at(*hitIter) << ")"
00794                                             << endl;
00795             
00796             MSG("AngClusterAna",Msg::kDebug)<< "centroTemp =" << "("
00797                                             << centroX << ","
00798                                             << centroY << ","
00799                                             << centroZ << ")"
00800                                             << endl;
00801            
00802             centroWeightX+=fX.at(*hitIter)*fX.at(*hitIter);
00803             centroWeightY+=fY.at(*hitIter)*fY.at(*hitIter);
00804             centroWeightZ+=fZ.at(*hitIter)*fZ.at(*hitIter);
00805             
00806 
00807         }//for (hitIter)
00808     }//for(cluIter)
00809 
00810     MSG("AngClusterAna",Msg::kDebug)<< "number of hits = " 
00811                                     << fClusterSize.at(fPrimShow)
00812                                     << endl;
00813         
00814     if (centroX == 0.0) centroX+=epsilon;
00815     if (centroY == 0.0) centroY+=epsilon;
00816     if (centroZ == 0.0) centroZ+=epsilon;
00817 
00818     centroWeightX/=centroX;
00819     centroWeightY/=centroY;
00820     centroWeightZ/=centroZ;
00821 
00822     centroX/=(fClusterSize.at(fPrimShow));
00823     centroY/=(fClusterSize.at(fPrimShow));
00824     centroZ/=(fClusterSize.at(fPrimShow));
00825   
00826     //Fill branch variables
00827     fAngCluster.fACluRmsShwAxis=hRPrime->GetRMS();
00828     fAngCluster.fACluRmsZAxis  =hRAxis->GetRMS();
00829     //     fAngCluster.fACluShwDirX   =centroWeightX;
00830     //     fAngCluster.fACluShwDirY   =centroWeightY;
00831     //     fAngCluster.fACluShwDirZ   =centroWeightZ;
00832 
00833     fAngCluster.fACluPrimEnergy     =totalHitEnergy;
00834     if (fTotalEventHitEnergy > 0.0)
00835         fAngCluster.fACluPrimEnergyRatio=totalHitEnergy/fTotalEventHitEnergy;
00836 
00837     fAngCluster.fACluShwDirX   =centroX;
00838     fAngCluster.fACluShwDirY   =centroY;
00839     fAngCluster.fACluShwDirZ   =centroZ;
00840 
00841     //Fill primary direction vector.
00842     fPrimDir.SetX(centroX);
00843     fPrimDir.SetY(centroY);
00844     fPrimDir.SetZ(centroZ);
00845 
00846     //Print variables
00847     MSG("AngClusterAna",Msg::kInfo)<< "fACluRmsShwAxis = "
00848                                    << fAngCluster.fACluRmsShwAxis
00849                                    << " fACluRmsZAxis = "
00850                                    << fAngCluster.fACluRmsZAxis
00851                                    << " fACluShwDirX = "
00852                                    << fAngCluster.fACluShwDirX
00853                                    << " fACluShwDirY = "
00854                                    << fAngCluster.fACluShwDirY
00855                                    << " fACluShwDirZ = "
00856                                    << fAngCluster.fACluShwDirZ
00857                                    << endl;
00858 
00859     //delete histograms
00860     if(hRZPrime)
00861         delete hRZPrime;
00862 
00863     if(hRZ)
00864         delete hRZ;
00865 
00866      if(hZPrime)
00867          delete hZPrime;
00868 
00869      if(hRPrime)
00870          delete hRPrime;
00871 
00872      if(hZAxis)
00873          delete hZAxis;
00874 
00875      if(hRAxis)
00876          delete hRAxis;
00877 
00878 }

void AngClusterAna::FindCentroidBlob ( TMatrixD &  grid,
const Int_t  nBinX,
const Int_t  nBinY,
Int_t  indX,
Int_t  indY,
TMatrixD &  blobCentro 
) [private]

Definition at line 127 of file AngClusterAna.cxx.

References Msg::kDebug, and MSG.

Referenced by FindCluster().

00133 {
00134     //Recursively find centroid agglomerations in the centroid histogram
00135     // No approximations are used, all centroid aggregates are found.
00136     
00137     //Make sure we did not go over the edges.    
00138     if (indX < 0 || indY < 0 || indX >= nBinX || indY >= nBinY)
00139         return;
00140     
00141     //Finish recursion if the next grid point is empty.
00142     if(TMath::Nint(grid(indX,indY)) != 1)
00143         return;
00144     
00145     //else
00146     grid(indX,indY) = 0.0;    //Mark as used
00147     blobCentro(indX,indY)=1.0;
00148   
00149     MSG("AngClusterAna",Msg::kDebug)<< "Adding point(" << indX
00150                                     <<"," << indY << ") to blob " 
00151                                     << endl;
00152   
00153     FindCentroidBlob(grid, nBinX, nBinY, indX - 1, indY, blobCentro);
00154     FindCentroidBlob(grid, nBinX, nBinY, indX + 1, indY, blobCentro);
00155     FindCentroidBlob(grid, nBinX, nBinY, indX, indY - 1, blobCentro);
00156     FindCentroidBlob(grid, nBinX, nBinY, indX, indY + 1, blobCentro);
00157     
00158 }

void AngClusterAna::FindCluster (  )  [private]

Definition at line 160 of file AngClusterAna.cxx.

References centroidX, centroidY, fClusterID, fClusterMap, fClusterSize, fE, FindCentroidBlob(), fNCluster, fPrimShow, fTotalEventHitEnergy, fX, fY, fZ, Nav::kDebug, Msg::kDebug, kDetectorPitch, Msg::kFatal, Msg::kInfo, ANtpDefaultValue::kInt, kMeuToGeV, Geo::kStripWidth, Msg::kWarning, and MSG.

Referenced by Analyze().

00161 {
00162 
00163    
00164     //Array of TVector3 hit objects containing
00165     //normal and XZY and ZYX CS rotations  
00166     std::vector<TVector3> hitVecArrayX(fZ.size());
00167     std::vector<TVector3> hitVecArrayY(fZ.size());
00168     
00169     //Vectors to be used in clustering
00170     VecFloat_t cosX;
00171     VecFloat_t cosY;
00172     cosX.assign(fZ.size(),0.0);
00173     cosY.assign(fZ.size(),0.0);
00174     
00175     fTotalEventHitEnergy=0.0;
00176 
00177     for (UInt_t n=0; n < hitVecArrayX.size(); n++){ //Loop over all 3D Hits
00178         
00179         (hitVecArrayX.at(n)).SetZ(fX.at(n));
00180         (hitVecArrayX.at(n)).SetY(fY.at(n));
00181         (hitVecArrayX.at(n)).SetX(fZ.at(n));
00182 
00183         (hitVecArrayY.at(n)).SetX(fX.at(n));
00184         (hitVecArrayY.at(n)).SetZ(fY.at(n));
00185         (hitVecArrayY.at(n)).SetY(fZ.at(n));
00186 
00187         cosX.at(n)=(hitVecArrayX.at(n)).CosTheta();
00188         cosY.at(n)=(hitVecArrayY.at(n)).CosTheta();
00189 
00190         //Calculate total 3D hit event energy  
00191         fTotalEventHitEnergy+=fE.at(n)*kMeuToGeV;
00192         
00193     }
00194 
00195     //============================================================
00196     //Start of cluster finding algorithm (nearest-neighbor method)
00197     //Do it in CosTheta X-Y space for now
00198     
00199     TMatrixD distHit(fZ.size(),fZ.size());   //Holds all distances 
00200                                              //between hits
00201     TMatrixD usedDist(fZ.size(),fZ.size());  //Keep track of already 
00202                                              //used distances
00203     
00204     VecFloat_t usedHit; //keep track of already used hits
00205     usedHit.assign(fZ.size(),0.0);
00206     
00207     Int_t nMin;  //index of smallest inter-hit distance
00208     Int_t kMin;
00209     Float_t minDist=999999.;
00210 
00211     //Calculate all inter-hit distances ommitting reciprocals
00212     for (UInt_t n=0; n < fZ.size(); n++){
00213         for (UInt_t k=0; k < fZ.size(); k++){
00214             distHit(n,k) =0.0;
00215             usedDist(n,k)=0.0;
00216             if (k > n){
00217 
00218                 distHit(n,k)= TMath::Sqrt((cosX.at(k)-cosX.at(n))
00219                                           *(cosX.at(k)-cosX.at(n))
00220                                           +(cosY.at(k)-cosY.at(n))
00221                                           *(cosY.at(k)-cosY.at(n)));
00222                
00223                 if (distHit(n,k) < minDist){
00224                     minDist=distHit(n,k);
00225                     nMin=n;
00226                     kMin=k;
00227                 }
00228                 
00229             } //if
00230         }//for(k)
00231     }//for(n)
00232     
00233     MSG("AngClusterAna",Msg::kDebug)<< "minDist[" 
00234                                     << nMin << "][" << kMin << "] = " 
00235                                     << distHit(nMin,kMin) << endl;
00236 
00237 
00238     Float_t radius=0.5; //limit radius for nearest neighbor 
00239 
00240     DeqInt_t aggHitSize; //Keeps track of the size of each aggregate 
00241 
00242     DeqDeqInt_t aggHitArray; //Container filled with all the 
00243                              //hit aggregate sets.
00244 
00245     UInt_t aggHitSizeMax=0;
00246 
00247     Int_t ahaIndex=0;
00248     Int_t ahaIndexMax=0;
00249 
00250     for (UInt_t n=0; n < fZ.size(); n++){
00251         for (UInt_t k=(n+1); k < fZ.size(); k++){
00252             if (k > n){
00253                 //Take the (n,k) pair as an aggregate seed 
00254                 if (TMath::Nint(usedDist(n,k)) == 0
00255                     && distHit(n,k) < radius
00256                     && distHit(n,k) > 0){
00257                     
00258                     usedDist(n,k)=1.0;
00259                     
00260                     DeqInt_t aggHit; //aggregate hit array
00261                                        
00262                     aggHit.push_back(n); //Store first hit from seed
00263                     aggHit.push_back(k); //Store second hit
00264                     
00265                     //Look for neighbor hits above the upper hit of 
00266                     //the seed pair
00267                     for (UInt_t kTemp=(n+1); kTemp < fZ.size(); kTemp++){
00268                         if (TMath::Nint(usedDist(n,kTemp)) == 0){
00269                             usedDist(n,kTemp)=1.0;
00270                             if (kTemp != k 
00271                                 && distHit(n,kTemp) > 0.0 
00272                                 && distHit(n,kTemp) < radius){
00273                                 
00274                                 aggHit.push_back(kTemp);
00275                                 usedDist(n,kTemp)=1.0;
00276 
00277                             }//if(kTemp !=k)
00278                                                        
00279                         }else continue; //if (usedDist(n,kTemp)) 
00280                   
00281                     }//for(kTemp)
00282                     
00283                     //Look for neighbor hits below the lower hit of 
00284                     //the seed pair
00285                     for (UInt_t nTemp=0; nTemp < k; nTemp++){
00286                         if (TMath::Nint(usedDist(nTemp,k)) == 0){
00287                             usedDist(nTemp,k)=1.0;
00288                             if (nTemp != n 
00289                                 && distHit(nTemp,k) > 0.0 
00290                                 && distHit(nTemp,k) < radius){
00291                                 
00292                                 aggHit.push_back(nTemp);
00293                                 usedDist(nTemp,k)=1.0;
00294 
00295                             }//if(nTemp !=n)
00296 
00297                         }else continue; //if (usedDist(nTemp,k)) 
00298                   
00299                     }//for(nTemp)
00300 
00301                     aggHitSize.push_back(aggHit.size()); //Record aggreg. size
00302                     aggHitArray.push_back(aggHit);       //Store hit aggregate
00303 
00304                     if (aggHit.size() > aggHitSizeMax){
00305                         aggHitSizeMax=aggHit.size();
00306                         ahaIndexMax=ahaIndex;
00307                     }
00308                     ahaIndex++;
00309                 }//if(distHit < radius)
00310                 
00311             }//if(k > n)
00312 
00313         }//for(k)
00314         
00315     }//for(n)
00316     
00317     
00318     MSG("AngClusterAna",Msg::kInfo)<< "Found "
00319                                    << aggHitArray.size() 
00320                                    << " aggregates."
00321                                    << endl;
00322     
00323     MSG("AngClusterAna",Msg::kInfo)<< "Largest aggregate contains "
00324                                    << aggHitSizeMax 
00325                                    << " Hits and has Index "
00326                                    << ahaIndexMax
00327                                    << endl;
00328  
00329     //Cluster determination:
00330     //Eliminate all overlapping aggregates in favor of the largest one.
00331     //Method: Calculate and histogram aggregate centroids. Run a 
00332     //recursion blob finder function on the histogram and determine 
00333     //high centroid density region bounds. From all the centroids
00334     //consistent with a region boundary, choose the one 
00335     //corresponding to the aggregate with most hits and call 
00336     //the aggregate a cluster.
00337 
00338     const Int_t kBinCentroX=10;
00339     const Int_t kBinCentroY=10;
00340 
00341     const Float_t kMinCentroX =-1.0;
00342     const Float_t kMaxCentroX = 1.0;
00343     const Float_t kMinCentroY =-1.0;
00344     const Float_t kMaxCentroY = 1.0;
00345 
00346     Float_t centSumX=0.0;
00347     Float_t centSumY=0.0;
00348     Float_t centValX=0.0;
00349     Float_t centValY=0.0;
00350     
00351     // Write out centroid histogram for debugging purposes 
00352     Bool_t kDebug=0;
00353     
00354     TH2F *centroHisto;
00355     centroHisto = new TH2F("centroHisto","CosX vs CosY centroid histogram"
00356                            ,kBinCentroX,kMinCentroX,kMaxCentroX
00357                            ,kBinCentroY,kMinCentroY,kMaxCentroY);
00358 
00359     centroidX.clear();
00360     centroidY.clear();
00361 
00362     for (IterDeqDeqInt_t ahaIter = aggHitArray.begin()
00363              ;ahaIter != aggHitArray.end()
00364              ; ++ahaIter ){
00365         centSumX=0.0;
00366         centSumY=0.0;
00367         for (IterDeqInt_t ahIter = ahaIter->begin()
00368                  ;ahIter < ahaIter->end()
00369                  ; ++ahIter){
00370             
00371             centSumX+=cosX.at((*ahIter));
00372             centSumY+=cosY.at((*ahIter)); 
00373         }//for(ahIter)
00374         
00375         centValX=centSumX/(static_cast <Float_t> (ahaIter->size()));
00376         centValY=centSumY/(static_cast <Float_t> (ahaIter->size()));
00377         
00378         centroidX.push_back(centValX);
00379         centroidY.push_back(centValY);
00380         
00381         centroHisto->Fill(centValX,centValY);
00382         
00383     }//for(ahaIter)
00384 
00385         
00386     TMatrixD gridHisto(kBinCentroX,kBinCentroY); //Centroid Grid
00387                                                  //for blob finding 
00388 
00389     const Float_t kMinCentroid=1.0; //Minimum number of centroids 
00390                                     //to be found in a  bin that 
00391                                     // will be part of a blob;
00392     
00393     if (kMinCentroid < 1.0){
00394         MSG("AngClusterAna",Msg::kFatal)<< "Attempting to cluster "
00395                                         << "empty space. Check "
00396                                         << "value of kMinCentroid"
00397                                         << endl;
00398     }
00399     
00400     Float_t centroStepX
00401         =(kMaxCentroX-kMinCentroX)/static_cast <Float_t> (kBinCentroX);
00402     Float_t centroStepY
00403         =(kMaxCentroY-kMinCentroY)/static_cast <Float_t> (kBinCentroY);
00404 
00405     //Map each centroid to bin position.
00406     VecInt_t centroBinX;
00407     centroBinX.assign(aggHitSize.size(),0);
00408     VecInt_t centroBinY;
00409     centroBinY.assign(aggHitSize.size(),0);
00410 
00411     //Populate blob grid.
00412     //Reminder: ROOT bin indexing starts at 1
00413     for (Int_t cBinX=0; cBinX < kBinCentroX; cBinX++){
00414       for (Int_t cBinY=0; cBinY < kBinCentroY; cBinY++){
00415 
00416           gridHisto(cBinX,cBinY)=0.0;
00417           
00418           //Find bin coordinates for each centroid
00419           for(UInt_t ah=0; ah < aggHitArray.size(); ah++){
00420 
00421               if (centroidX.at(ah) > (centroHisto->GetXaxis()
00422                                       ->GetBinLowEdge(cBinX+1)) 
00423                   && centroidX.at(ah) < centroStepX
00424                                         +(centroHisto
00425                                           ->GetXaxis()
00426                                           ->GetBinLowEdge(cBinX+1)) 
00427                   && centroidY.at(ah) > (centroHisto->GetYaxis()
00428                                          ->GetBinLowEdge(cBinY+1)) 
00429                   && centroidY.at(ah) < centroStepY
00430                                         +(centroHisto
00431                                           ->GetYaxis()
00432                                           ->GetBinLowEdge(cBinY+1))){
00433               
00434                   centroBinX.at(ah)=cBinX;
00435                   centroBinY.at(ah)=cBinY;
00436 
00437               }//if(centroid)
00438                   
00439           }//for(ah)
00440 
00441 
00442           //Ignore bins with low centroid density
00443           Int_t cBin=centroHisto->GetBin(cBinX+1,cBinY+1);
00444           if (centroHisto->GetBinContent(cBin) >= kMinCentroid ){
00445           
00446               gridHisto(cBinX,cBinY)=1.0;
00447 
00448           }//if(content)
00449       }//for(cBinY)
00450     }//for(cBinX)
00451 
00452     TMatrixD blobCentro(kBinCentroX,kBinCentroY); //Contains all centroids
00453                                                   //on a given blob
00454 
00455     DeqTMatrixD blobArray; //Contains all the found blobs 
00456 
00457     //Find blobs recursively in the centroid histogram
00458     for (Int_t nX=0; nX < kBinCentroX; nX++){
00459         for (Int_t nY=0; nY < kBinCentroY; nY++){
00460             blobCentro(nX,nY)=0.0;
00461             if(TMath::Nint(gridHisto(nX,nY))==1.0){
00462                 
00463                 FindCentroidBlob(gridHisto
00464                                  ,kBinCentroX
00465                                  ,kBinCentroY
00466                                  ,nX
00467                                  ,nY
00468                                  ,blobCentro);
00469 
00470                 blobArray.push_back(blobCentro);
00471                 if(kDebug) blobCentro.Print();
00472                 blobCentro.Zero();
00473             }//if(gridHisto)
00474         }//for(nX)
00475     }//for(nY)
00476 
00477     
00478     Int_t sizeMax=-1;   //keep track of max agg size within a blob
00479     Int_t cluSelect=-1; //index of max agg size in a blob
00480 
00481     VecInt_t cluAggMap; //Correspondance between final cluster and
00482                         //largest Hit aggregate for that cluster
00483     cluAggMap.assign(aggHitArray.size(),0);
00484 
00485     Int_t cluSizeMax=0;   //keep track of maximum size over all blobs
00486     Int_t cluPrimShow=-1; //index of largest aggregate over all blobs
00487     Int_t aggIndexMax=-1;
00488 
00489     fClusterSize.clear(); //Prepare for the new event.
00490     fClusterMap.clear();
00491 
00492     Int_t blobIndex=0;
00493 
00494     //Find the largest aggregate for each blob and call that a cluster
00495     for (IterDeqTMatrixD baIter = blobArray.begin()
00496              ;baIter != blobArray.end()
00497              ; ++baIter ){
00498 
00499         sizeMax=-1;
00500         cluSelect=-1;
00501 
00502         for (Int_t i = 0; i < kBinCentroX; i++){
00503             for (Int_t j = 0; j < kBinCentroY; j++){
00504                 if(TMath::Nint((*baIter)(i,j))==1){
00505 
00506                     for(UInt_t ah=0; ah < aggHitArray.size(); ah++){
00507 
00508                         if (centroBinX.at(ah)==i && centroBinY.at(ah)==j){
00509 
00510                             if(aggHitSize.at(ah) > sizeMax){
00511                                 sizeMax=aggHitSize.at(ah);
00512                                 cluSelect=ah;
00513                             }//if(aggHitSize)
00514 
00515                         }//if(centroBin)
00516 
00517                     }//for(ah)
00518 
00519                 }//if(*baIter(i,j)==1)
00520             }//for(i)
00521         }//for(i)
00522 
00523         if(cluSelect >=0){
00524             cluAggMap.at(blobIndex)=cluSelect;
00525 
00526             //Fill cluster size member deque;
00527             fClusterSize.push_back(aggHitSize.at(cluSelect));
00528 
00529             //Fill cluster map member container
00530             fClusterMap.push_back(aggHitArray.at(cluSelect));
00531 
00532             //Determination of largest cluster index ("primary shower")
00533             if (aggHitSize.at(cluSelect) > cluSizeMax){
00534                 cluSizeMax=aggHitSize.at(cluSelect);
00535                 cluPrimShow=blobIndex;
00536                 aggIndexMax=cluSelect;
00537             }
00538 
00539             MSG("AngClusterAna",Msg::kDebug)<< "Cluster "
00540                                        << blobIndex
00541                                        << " largest agg is "
00542                                        << cluSelect
00543                                        << " with "
00544                                        << sizeMax
00545                                        << " Hits"
00546                                        << endl;
00547 
00548             blobIndex++;
00549 
00550         } else{
00551             MSG("AngClusterAna",Msg::kWarning)<< "Unable to find "
00552                                            << " largest cluster."
00553                                            << " Quitting."
00554                                            << endl << endl;
00555             break;
00556         }
00557 
00558     }//for(baIter)
00559 
00560 
00561 
00562     if(cluPrimShow >= 0){
00563         fPrimShow=cluPrimShow;
00564         MSG("AngClusterAna",Msg::kInfo)<< "Primary Cluster "
00565                                        << "found in blob "
00566                                        << cluPrimShow << "/"
00567                                        << blobArray.size()
00568                                        << " contains "
00569                                        << aggHitSize.at
00570                                        (cluAggMap.at(cluPrimShow))
00571                                        << " hits and was found in aggregate "
00572                                        << aggIndexMax
00573                                        << endl;
00574     }else {
00575 
00576         MSG("AngClusterAna",Msg::kInfo)<< "No primary cluster "
00577                                        << " found in event."
00578                                        << endl << endl;
00579         if(centroHisto)
00580             delete centroHisto;
00581 
00582         fPrimShow=ANtpDefVal::kInt;
00583 
00584         return;
00585     }
00586 
00587 
00588     //Find all high energy hits close to the vertex (low angular resolution)
00589     DeqInt_t highEnergyHits;
00590 
00591     for (UInt_t n=0; n < fZ.size(); n++){
00592         if(fZ.at(n)/kDetectorPitch > 0. && fZ.at(n)/kDetectorPitch < 4.){
00593             if(TMath::Sqrt(fX.at(n)*fX.at(n)+fY.at(n)*fY.at(n))
00594                /kStripWidth < 4.){
00595 
00596                 if(fE.at(n) > 5.0){
00597                     highEnergyHits.push_back(n);
00598                     //Add energy of close hits to total event energy
00599                     fTotalEventHitEnergy+=fE.at(n)*kMeuToGeV;
00600                     MSG("AngClusterAna",Msg::kDebug)<< "(X,Y,Z,E) HighHits = "
00601                                                    << "("
00602                                                    << fX.at(n) << ","
00603                                                    << fY.at(n) << ","
00604                                                    << fZ.at(n) << ","
00605                                                    << fE.at(n) << ")"
00606                                                    << endl;
00607                 }//for(fE.at(n))
00608             }//for(fX.at(n))
00609         } //for(fZ.at(n))
00610     }// for(n)
00611 
00612     //Update the primary shower cluster with the high energy hits above
00613     DeqDeqInt_t clusterMapTemp;
00614     DeqInt_t    hitTemp;
00615     Int_t       cluIndexTemp=0;
00616 
00617     for (IterDeqDeqInt_t cluIter = fClusterMap.begin()
00618              ;cluIter != fClusterMap.end()
00619              ; ++cluIter ){
00620 
00621         hitTemp=*cluIter;
00622 
00623         if (cluIndexTemp==fPrimShow){
00624 
00625             for (UInt_t n=0; n < highEnergyHits.size(); n++){
00626                 hitTemp.push_back(highEnergyHits.at(n));
00627             }//for(n)
00628 
00629         }//if(fPrimShow)
00630 
00631         clusterMapTemp.push_back(hitTemp);
00632         cluIndexTemp++;
00633 
00634     }//for(cluIter)
00635 
00636     //Fill member variables
00637     fClusterMap.clear();
00638     fClusterMap=clusterMapTemp;
00639 
00640     fClusterSize.at(fPrimShow)+=highEnergyHits.size();
00641 
00642     fNCluster=fClusterMap.size();
00643 
00644     Int_t cluIndex=0;
00645 
00646     fClusterID.clear();
00647 
00648     fClusterID.assign(fZ.size(),-1); //hits outside any cluster get -1.
00649 
00650     //Build the clusterID vector (returns the cluster one hit belongs to.)
00651     for (IterDeqDeqInt_t cluIter = fClusterMap.begin()
00652              ;cluIter != fClusterMap.end()
00653              ; ++cluIter ){
00654         for (IterDeqInt_t hitIter = cluIter->begin()
00655                  ;hitIter < cluIter->end()
00656                  ; ++hitIter){
00657 
00658             fClusterID.at((*hitIter))=cluIndex;
00659 
00660         }//for (hitIter)
00661 
00662         cluIndex++;
00663 
00664     }//for(cluIter)
00665 
00666 
00667 
00668     //Delete centroid histogram
00669     if(centroHisto)
00670         delete centroHisto;
00671 
00672 }

void AngClusterAna::GetAngCluster ( Int_t &  primShow,
DeqDeqInt_t clusterMap,
TVector3 &  primDir 
)

Definition at line 104 of file AngClusterAna.cxx.

References fClusterMap, fPrimDir, fPrimShow, Msg::kWarning, and MSG.

Referenced by NueRecordAna::Analyze(), and NueDisplayModule::Analyze().

00107 {
00108     
00109     if(fClusterMap.size()==0){
00110         MSG("AngClusterAna",Msg::kWarning)<< "Primary cluster not found for " 
00111                                        << "event, stopping any further"
00112                                        << " clustering related processing"
00113                                        << endl;            
00114         return;
00115     }
00116 
00117     if(fPrimDir.X()==0.0 && fPrimDir.Y()==0.0 && fPrimDir.Z()==0) return;
00118 
00119     //Reference relevant quantities.
00120     primShow  =fPrimShow;
00121     clusterMap=fClusterMap;
00122     primDir   =fPrimDir;
00123 }

AngClusterAna& AngClusterAna::operator= ( const AngClusterAna rhs  )  [private]

void AngClusterAna::Reset (  ) 

Definition at line 1033 of file AngClusterAna.cxx.

01034 {
01035 
01036 
01037 }

void AngClusterAna::Set3DHit ( DeqFloat_t x,
DeqFloat_t y,
DeqFloat_t z,
DeqFloat_t e 
)

Definition at line 88 of file AngClusterAna.cxx.

References fE, fX, fY, and fZ.

Referenced by NueRecordAna::Analyze(), and NueDisplayModule::Analyze().

00091                                              {
00092 
00093     if(x.size()!=0 && y.size()!=0 && z.size()!=0 && e.size()!=0){
00094 
00095         fX=x;
00096         fY=y;
00097         fZ=z;
00098         fE=e;  
00099     
00100     }
00101 
00102 }

void AngClusterAna::WeightedEnergy ( int  evtn,
RecRecordImp< RecCandHeader > *  srobj 
)

Definition at line 880 of file AngClusterAna.cxx.

References NueAnaBase::evtstp0mip, NueAnaBase::evtstp1mip, AngCluster::fACluShwDirX, AngCluster::fACluShwDirY, AngCluster::fACluShwDirZ, fAngCluster, SntpHelpers::GetEvent(), SntpHelpers::GetStrip(), SntpHelpers::GetStripIndex(), ReleaseType::IsCedar(), Msg::kDebug, Msg::kError, PlaneView::kU, PlaneView::kV, MSG, NtpSREvent::nstrip, NtpSRStrip::plane, NtpSRVertex::plane, NtpSRStrip::planeview, NueAnaBase::release, NtpSRStrip::tpos, NtpSRVertex::u, NtpSRVertex::v, NtpSREvent::vtx, AngCluster::weightedPH0, AngCluster::weightedPH1, AngCluster::weightedPH2, and AngCluster::weightedPH3.

Referenced by Analyze().

00880                                                                               {
00881   if(srobj==0){
00882     return;
00883   }
00884   if(((dynamic_cast<NtpStRecord *>(srobj))==0)&&
00885      ((dynamic_cast<NtpSRRecord *>(srobj))==0)){
00886     return;
00887   }
00888 
00889   MSG("ShwfitAna",Msg::kDebug)<<"In ShwfitAna::Analyze"<<endl;
00890   MSG("ShwfitAna",Msg::kDebug)<<"On Snarl "<<srobj->GetHeader().GetSnarl()
00891                               <<" event "<<evtn<<endl;
00892 
00893 //  Reset(srobj->GetHeader().GetSnarl(),evtn);
00894 
00895   NtpSREvent *event = SntpHelpers::GetEvent(evtn,srobj);
00896 
00897   if(!event){
00898       MSG("ShwfitAna",Msg::kError)<<"Couldn't get event "<<evtn
00899                                    <<" from Snarl "<<srobj->GetHeader().GetSnarl()<<endl;
00900       return;
00901    }
00902 
00903   Float_t cent_x = fAngCluster.fACluShwDirX;
00904   Float_t cent_y = fAngCluster.fACluShwDirY;
00905   Float_t cent_z = fAngCluster.fACluShwDirZ;
00906   
00907   Float_t cent_u = TMath::Sqrt(2)*(cent_x-cent_y);
00908   Float_t cent_v = TMath::Sqrt(2)*(cent_x+cent_y);
00909 
00910   Int_t MaxStripU = 0;
00911   Int_t MaxStripV = 0;
00912   Float_t MaxStripU_ph = 0;
00913   Float_t MaxStripV_ph = 0;
00914 
00915   Float_t Weighted_ph0 = 0.0;
00916   Float_t Weighted_ph1 = 0.0;
00917   Float_t Weighted_ph2 = 0.0;
00918   Float_t Weighted_ph3 = 0.0;
00919 
00920   Int_t vtxPlane = event->vtx.plane;
00921   Float_t vtxU = event->vtx.u;
00922   Float_t vtxV = event->vtx.v;
00923 
00924   if(ReleaseType::IsCedar(release)){
00925     NtpStRecord* st = dynamic_cast<NtpStRecord *>(srobj);
00926     NtpVtxFinder vtxf(evtn, st);
00927     if(vtxf.FindVertex() > 0){
00928        vtxPlane = vtxf.VtxPlane();
00929        vtxU = vtxf.VtxU();
00930        vtxV = vtxf.VtxV();
00931     }
00932   }
00933 
00934   for(int i=0;i<event->nstrip;i++){
00935     Int_t index = SntpHelpers::GetStripIndex(i,event);
00936     NtpSRStrip *strip = SntpHelpers::GetStrip(index,srobj);
00937     if(!strip){
00938       continue;
00939     }
00940     if(!evtstp0mip){
00941        MSG("AngCluster",Msg::kError)<<"No mip strip information"<<endl;
00942        continue;
00943     }
00944 
00945 
00946     Float_t Strip_ph_meu = evtstp0mip[index] + evtstp1mip[index];
00947     //(strip->ph0.sigcor+strip->ph1.sigcor)/sigcormeu;
00948 
00949     if(strip->plane>=event->vtx.plane && strip->plane<=event->vtx.plane+(cent_z/0.0354) ){
00950       if(strip->planeview==PlaneView::kU){
00951         if(strip->tpos-event->vtx.u+cent_u*(strip->plane-event->vtx.plane)/(cent_z/0.0354)<.0205){
00952           if( Strip_ph_meu>MaxStripU_ph ){MaxStripU_ph=Strip_ph_meu; MaxStripU = i;}
00953         }
00954       }else if(strip->planeview==PlaneView::kV){
00955         if(strip->tpos-event->vtx.v+cent_v*(strip->plane-event->vtx.plane)/(cent_z/0.0354)<.0205){
00956           if( Strip_ph_meu>MaxStripV_ph ){MaxStripV_ph=Strip_ph_meu; MaxStripV = i;}
00957         }
00958       }
00959     }
00960   }
00961 
00962   Int_t Main_index_u = SntpHelpers::GetStripIndex(MaxStripU,event);
00963   NtpSRStrip *Main_strip_u = SntpHelpers::GetStrip(Main_index_u,srobj);
00964   Int_t Main_index_v = SntpHelpers::GetStripIndex(MaxStripV,event);
00965   NtpSRStrip *Main_strip_v = SntpHelpers::GetStrip(Main_index_v,srobj);
00966 
00967   for(int i=0;i<event->nstrip;i++){
00968     Int_t index = SntpHelpers::GetStripIndex(i,event);
00969     NtpSRStrip *strip = SntpHelpers::GetStrip(index,srobj);
00970     if(!strip){
00971       continue;
00972     }
00973     if(!evtstp0mip){
00974        MSG("MSTCalcAna",Msg::kError)<<"No mip strip information"<<endl;
00975        continue;
00976     }
00977 
00978     float charge = evtstp0mip[index] + evtstp1mip[index];;
00979     //  = (strip->ph0.sigcor+strip->ph1.sigcor)/sigcormeu
00980 
00981 
00982     Float_t Strip_ph_meu0 = charge;
00983     Float_t Strip_ph_meu1 = charge;
00984     Float_t Strip_ph_meu2 = charge;
00985     Float_t Strip_ph_meu3 = charge;
00986 
00987     if(strip->planeview==PlaneView::kU){
00988       if(Main_strip_u->plane-strip->plane>0){
00989         Strip_ph_meu0*=TMath::Sqrt(2*TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Sqrt(TMath::Abs(Main_strip_u->tpos-strip->tpos));
00990         Strip_ph_meu1*=TMath::Sqrt(2*TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 20*TMath::Abs(Main_strip_u->tpos-strip->tpos);
00991         Strip_ph_meu2*=TMath::Sqrt( (5*TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_u->tpos-strip->tpos) );
00992         Strip_ph_meu3*=TMath::Sqrt( (2*TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_u->tpos-strip->tpos) );
00993 
00994       }else{
00995         Strip_ph_meu0*=TMath::Sqrt(TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Sqrt(TMath::Abs(Main_strip_u->tpos-strip->tpos));
00996         Strip_ph_meu1*=TMath::Sqrt(TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 20*TMath::Abs(Main_strip_u->tpos-strip->tpos);
00997         Strip_ph_meu2*=TMath::Sqrt( (TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_u->tpos-strip->tpos) );
00998         Strip_ph_meu3*=TMath::Sqrt( (TMath::Abs(Main_strip_u->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_u->tpos-strip->tpos) );
00999 
01000       }
01001 
01002     }else if(strip->planeview==PlaneView::kV){
01003       if(Main_strip_v->plane-strip->plane>0){
01004         Strip_ph_meu0*=TMath::Sqrt(2*TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Sqrt(TMath::Abs(Main_strip_v->tpos-strip->tpos));
01005         Strip_ph_meu1*=TMath::Sqrt(2*TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 20*TMath::Abs(Main_strip_v->tpos-strip->tpos);
01006         Strip_ph_meu2*=TMath::Sqrt( (5*TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_v->tpos-strip->tpos) );
01007         Strip_ph_meu3*=TMath::Sqrt( (2*TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_v->tpos-strip->tpos) );
01008 
01009       }else{
01010         Strip_ph_meu0*=TMath::Sqrt(TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Sqrt(TMath::Abs(Main_strip_v->tpos-strip->tpos));
01011         Strip_ph_meu1*=TMath::Sqrt(TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 20*TMath::Abs(Main_strip_v->tpos-strip->tpos);
01012         Strip_ph_meu2*=TMath::Sqrt( (TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_v->tpos-strip->tpos) );
01013         Strip_ph_meu3*=TMath::Sqrt( (TMath::Abs(Main_strip_v->plane-strip->plane)*0.0354) + 40*TMath::Abs(Main_strip_v->tpos-strip->tpos) );
01014       }
01015 
01016     }
01017 
01018     Weighted_ph0+=Strip_ph_meu0;
01019     Weighted_ph1+=Strip_ph_meu1;
01020     Weighted_ph2+=Strip_ph_meu2;
01021     Weighted_ph3+=Strip_ph_meu3;
01022   }
01023 
01024   if(MaxStripU==0 && MaxStripV==0){Weighted_ph0=-100;Weighted_ph1=-100;Weighted_ph2=-100;Weighted_ph3=-100;}
01025   fAngCluster.weightedPH0 = Weighted_ph0;
01026   fAngCluster.weightedPH1 = Weighted_ph1;
01027   fAngCluster.weightedPH2 = Weighted_ph2;
01028   fAngCluster.weightedPH3 = Weighted_ph3;
01029 
01030 }


Member Data Documentation

DeqFloat_t AngClusterAna::centroidX [private]

Definition at line 93 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and FindCluster().

DeqFloat_t AngClusterAna::centroidY [private]

Definition at line 94 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and FindCluster().

AngCluster& AngClusterAna::fAngCluster [private]

Definition at line 87 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and WeightedEnergy().

VecInt_t AngClusterAna::fClusterID

Definition at line 73 of file AngClusterAna.h.

Referenced by FindCluster().

DeqDeqInt_t AngClusterAna::fClusterMap

Definition at line 79 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), FindCluster(), and GetAngCluster().

DeqInt_t AngClusterAna::fClusterSize

Definition at line 74 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and FindCluster().

DeqFloat_t AngClusterAna::fE [private]

Definition at line 100 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), FindCluster(), and Set3DHit().

Int_t AngClusterAna::fNCluster

Definition at line 76 of file AngClusterAna.h.

Referenced by FindCluster().

TVector3 AngClusterAna::fPrimDir

Definition at line 81 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and GetAngCluster().

Int_t AngClusterAna::fPrimShow

Definition at line 77 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), FindCluster(), and GetAngCluster().

Float_t AngClusterAna::fTotalEventHitEnergy

Definition at line 83 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), and FindCluster().

DeqFloat_t AngClusterAna::fX [private]

Definition at line 97 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), FindCluster(), and Set3DHit().

DeqFloat_t AngClusterAna::fY [private]

Definition at line 98 of file AngClusterAna.h.

Referenced by ClusterVarCalc(), FindCluster(), and Set3DHit().

DeqFloat_t AngClusterAna::fZ [private]

Definition at line 99 of file AngClusterAna.h.

Referenced by Analyze(), ClusterVarCalc(), FindCluster(), and Set3DHit().


The documentation for this class was generated from the following files:
Generated on Wed Sep 10 22:50:45 2014 for loon by  doxygen 1.4.7