Changeset 240 in Idarraga

Timestamp:

Oct 10, 2011, 11:56:47 AM (13 years ago)

Author:

idarraga

Message:

 

Location:

mafalda

Files:

• AnalysisCore/MediPixAnalysisManager.h (modified) (2 diffs)
• MAFTools/MAFTools.cpp (modified) (2 diffs)
• MAFTools/MAFTools.h (modified) (2 diffs)
• MPXAlgo/MediPixAlgo.cpp (modified) (1 diff)
• MPXAlgo/MediPixAlgo.h (modified) (1 diff)
• ShallowAngleFEIX/ShallowAngleFEIX.cpp (modified) (6 diffs)
• ShallowAngleFEIX/ShallowAngleFEIX.h (modified) (1 diff)
• ShallowAngleFEIX/configuration_algos_ShallowAngleFEIX.txt (modified) (1 diff)
• ShallowAngleFEIX/runAngle.C (modified) (3 diffs)
• ShallowAngleFEIX/runNewAlgo.C (modified) (7 diffs)

mafalda/AnalysisCore/MediPixAnalysisManager.h

@@ -18 +18 @@
 #include <fstream>
 #include <string>
+#include <map>
 
 #include "MediPixAnalysisCore.h"
@@ -96 +97 @@
         };
 
+        std::map<int,int> GetTOTMap()
+        {return analysisCore->m_frameXC;};
+
         inline Int_t GetnEntriesPad()
         {return analysisCore->m_nEntriesPad;};

mafalda/MAFTools/MAFTools.cpp

@@ -13 +13 @@
 #include "MPXAlgo/MediPixAlgo.h"
 
-#include "BlobsFinder/BlobsFinder.h"
+//#include "BlobsFinder/BlobsFinder.h"
 
 #include <set>
@@ -252 +252 @@
 }
 
+
+/**
+ *  All clustering stuff
+ *
+ */
+bool StartBlob(int xi, int yi, Int_t disctTolerance, AllBlobsContainer * blobsContainer, blob * oneBlob, int maxx, int maxy, std::map<int,int> totmap){
+
+        // I will recluster here on a cluster already found (if discontinuity > 0).
+        // I will have to rewind the internal iterator so the search is possible again.
+        //(*oneBlob.blobItr).second = 0;
+
+        pair<Int_t, Int_t> startPoint = make_pair(xi, yi);
+
+        /////////////////////////////////////////////////////////////////////////////////////
+        // Check if a blob containing this point has already been saved
+        //  I only need to find the 'startPoint' in 'bloblContentSet' in each blob
+        vector<blob>::iterator blobsItr = blobsContainer->allBlobs.begin();
+        set< pair<Int_t, Int_t> >::iterator itr;
+        for( ; blobsItr != blobsContainer->allBlobs.end() ; blobsItr++)
+        {
+                itr = (*blobsItr).blobContentSet.find(startPoint);
+                if(itr != (*blobsItr).blobContentSet.end()) // point found in previous blob !!!
+                        return false;
+        }
+
+        // If we hit this point we are ready to start a new blob
+        // Insert in <set>, push_back in <list>, first time
+        oneBlob->blobContentSet.insert( startPoint );
+        oneBlob->blobContent.push_back( pair< pair<Int_t, Int_t>, Int_t > (startPoint, __CENTER));
+        oneBlob->blobItr = oneBlob->blobContent.begin();
+
+        // Follow
+        steerSpiral spiral;
+        FollowBlob(oneBlob, &spiral, disctTolerance, maxx, maxy, totmap);
+
+        return true;
+}
+
+/**
+ *  Using recursion to follow a blob up to its end.
+ *
+ */
+bool FollowBlob(blob * oneBlob, steerSpiral * spiral, int disctTolerance, int maxx, int maxy, std::map<int,int> totmap){
+
+        //cout << " +++ looking at = " << (*(oneBlob->blobItr)).first.first << ", " << (*(oneBlob->blobItr)).first.second << endl;
+
+        Int_t spiralEnds = GetLengthOfSpiral(disctTolerance);
+
+        // test insertion in the set
+        pair< set < pair<Int_t, Int_t> >::iterator , bool> rtest;
+
+        // spiral starts, i.e. search through the neighbors
+        RewindSpiral(spiral);
+
+        // spiral starts at
+        pair<Int_t, Int_t> nextNeighbor = (*oneBlob->blobItr).first;
+
+        (*oneBlob->blobItr).second = 0;
+        //cout << " +++ iterator = " << (*oneBlob->blobItr).second << ", " << spiralEnds << endl;
+
+        while((*oneBlob->blobItr).second < spiralEnds) {
+
+                // try current position, next neighbor
+                //nextNeighbor = GetNextPosition( (*oneBlob.blobItr).first );
+                nextNeighbor = GetNextPosition( nextNeighbor, spiral );
+
+                //cout << "next: " <<  nextNeighbor.first << " , " << nextNeighbor.second << " : " << totmap[ nextNeighbor.second * maxx + nextNeighbor.first ] << endl;
+
+                // see if the next position does not fall in the pad
+                /*
+                if(IsUnsafePosition(nextNeighbor, maxx, maxy)) {
+                        // increment neighbor counter, and skip the rest withing the while loop
+                        (*oneBlob.blobItr).second++;
+                        continue;
+                }
+                 */
+                //Log << MSG::LOOP_DEBUG << "next: " <<  nextNeighbor.first << " , " << nextNeighbor.second << " ---> "
+                //<< GetMatrixElement(nextNeighbor) << endreq;
+
+                // if there is something
+                if(totmap[ nextNeighbor.second * maxx + nextNeighbor.first ] != 0)
+                {
+                        //Log << MSG::LOOP_DEBUG << "next: " <<  nextNeighbor.first << " , " << nextNeighbor.second << " ---> "
+                        //              << GetMatrixElement(nextNeighbor) << endreq;
+
+                        //cout << "next: " <<  nextNeighbor.first << " , " << nextNeighbor.second << " ---> "
+                                        //<< totmap[ nextNeighbor.second * maxx + nextNeighbor.first ] << endl;
+
+                        // check the Set see if it existed
+                        rtest = oneBlob->blobContentSet.insert( nextNeighbor );
+                        // if insertion is possible it means this point didn't exist.  So, push_back new entry in the list
+                        if(rtest.second == true) {
+                                oneBlob->blobContent.push_back( pair< pair<Int_t, Int_t>, Int_t > (nextNeighbor, __CENTER) );
+                        }
+
+                }
+
+                // increment neighbor counter
+                (*oneBlob->blobItr).second++;
+        }
+
+        // go to the next in the list, if there are any left
+        if(++oneBlob->blobItr != oneBlob->blobContent.end()) {
+                FollowBlob(oneBlob, spiral, disctTolerance, maxx, maxy, totmap);
+        }
+
+        return true;
+}
+
+/**
+ * Calculate length of the spiral through the formula :
+ *  (2*tolerancePixels + 2)*4 + recursive_call(--tolerancePixels)
+ *
+ *  disc --> length
+ *    0        8
+ *    1       24
+ *    2       48
+ *    3       80
+ *    and so on ...
+ *
+ */
+Int_t GetLengthOfSpiral(Int_t tolerancePixels){
+
+        if(tolerancePixels == -1)
+                return 0;
+        else
+                return (2*tolerancePixels + 2)*4 +
+                GetLengthOfSpiral(--tolerancePixels);
+
+}
+
+/**
+ *  Follows a spiral shape around a pixel
+ *
+ */
+pair<Int_t, Int_t> GetNextPosition(pair<Int_t, Int_t> current, steerSpiral * spiral) {
+
+        pair<Int_t, Int_t> newPos;
+
+        if(spiral->xySwitch == X_STEP)
+        {
+                newPos.first = current.first - spiral->dir;
+                newPos.second = current.second;
+                spiral->xCntr++;
+
+                if(spiral->xCntr > spiral->localMax)
+                        spiral->xySwitch = Y_STEP;
+        }
+        else if(spiral->xySwitch == Y_STEP)
+        {
+                newPos.second = current.second - spiral->dir;
+                newPos.first = current.first;
+                spiral->yCntr++;
+
+                if(spiral->yCntr > spiral->localMax)
+                {
+                        spiral->xySwitch = X_STEP;
+                        spiral->localMax++;
+                        spiral->xCntr = 1;
+                        spiral->yCntr = 1;
+                        spiral->dir *= -1; // change direction
+                }
+        }
+
+        return newPos;
+}
+
+void RewindSpiral(steerSpiral * spiral){
+
+        spiral->xySwitch = X_STEP;
+        spiral->localMax = 1;
+        spiral->xCntr = 1;
+        spiral->yCntr = 1;
+        spiral->dir = 1;
+
+}
+
+/**
+ *  Check if the position we are about to step in is safe, i.e. see if
+ *  it falls inside the pad.
+ *
+ */
+bool IsUnsafePosition(pair<Int_t, Int_t> pos, int maxx, int maxy){
+
+        if(pos.first < 0 || pos.second < 0)
+                return true;
+        if(pos.first > maxx-1 || pos.second > maxy-1)
+                return true;
+
+        return false;
+}
+
+void ClearOneBlobData(blob * oneBlob){
+
+        // clean up
+        oneBlob->blobContent.clear();
+        oneBlob->blobContentSet.clear();
+
+        oneBlob->bP.nPixels = 0;
+        oneBlob->bP.totalCharge = 0;
+        oneBlob->bP.width_x = 0;
+        oneBlob->bP.width_y = 0;
+        oneBlob->bP.geoCenter_x = 0;
+        oneBlob->bP.geoCenter_y = 0;
+        oneBlob->bP.weightedCenter_x = 0;
+        oneBlob->bP.weightedCenter_y = 0;
+        oneBlob->bP.boxArea = 0;
+        oneBlob->bP.circleArea = 0.;
+        oneBlob->bP.minToGeoCenter = 0.;
+        oneBlob->bP.maxToGeoCenter = 0.;
+
+        oneBlob->bP.lvl1.clear();
+
+}
+
+int DigitalBlobReclustering(int discontinuityTolerance, AllBlobsContainer * bContainer, blob bl,
+                int maxx, int maxy, std::map<int,int> totmap){
+
+        // Start point of a blob
+        // This clustering runs on the contents of an existing blob
+        set< pair<Int_t, Int_t> > bCSet = bl.GetContentSet();
+        set< pair<Int_t, Int_t> >::iterator bCSetItr = bCSet.begin();
+
+        // Blob structure to find
+        blob * oneBlob = new blob;
+        ClearOneBlobData(oneBlob);
+
+        for ( ; bCSetItr != bCSet.end() ; bCSetItr++) {
+
+                int xi = (*bCSetItr).first;
+                int yi = (*bCSetItr).second;
+
+                if( StartBlob(xi, yi, discontinuityTolerance, bContainer, oneBlob, maxx, maxy, totmap) ){
+                        bContainer->allBlobs.push_back(*oneBlob);
+                        ClearOneBlobData(oneBlob);
+                }
+
+        }
+
+        delete oneBlob;
+
+        return 0;
+}
+
 }
 

mafalda/MAFTools/MAFTools.h

@@ -12 +12 @@
 #include <TROOT.h>
 
-class blob;
+#include "BlobsFinder/BlobsFinder.h"
+
+//class blob;
 class MediPixAlgo;
+//class AllBlobsContainer;
+//typedef struct steerSpiral;
 
 using namespace std;
@@ -56 +60 @@
   Bool_t BlobAtADistanceFromEdges(blob, vector<pair<Float_t, Float_t> >, Int_t, Int_t, Int_t, Int_t);
 
+  /**
+   * Clustering stuff
+   */
+  int DigitalBlobReclustering(int, AllBlobsContainer *, blob, int, int, std::map<int,int>);
+  bool StartBlob(int, int, int, AllBlobsContainer *, blob *, int, int, std::map<int,int>);
+  bool FollowBlob(blob *, steerSpiral *, int, int, int, std::map<int,int>);
+  void RewindSpiral(steerSpiral *);
+  Int_t GetLengthOfSpiral(Int_t);
+  pair<Int_t, Int_t> GetNextPosition(pair<Int_t, Int_t>, steerSpiral *);
+  bool IsUnsafePosition(pair<Int_t, Int_t>, int, int);
+  void ClearOneBlobData(blob *);
 
-  /* Dump contents of a blobl */
+  /* Dump contents of a blob */
   void DumpBlobContents(blob);
 

mafalda/MPXAlgo/MediPixAlgo.cpp

@@ -210 +210 @@
 Int_t MediPixAlgo::GetMatrixElement(Int_t col, Int_t row){ 
         return m_myManager->GetMatrixElement(col, row);
+}
+
+std::map<int,int> MediPixAlgo::GetTOTMap(){
+        return m_myManager->GetTOTMap();
 }
 

mafalda/MPXAlgo/MediPixAlgo.h

@@ -66 +66 @@
   Int_t GetMatrixWidth(){return GetMatrixXdim();}; // same
   Int_t GetWidth(){return GetMatrixXdim();}; // same
+
+  std::map<int,int> GetTOTMap();
 
   Int_t GetMatrixYdim();

mafalda/ShallowAngleFEIX/ShallowAngleFEIX.cpp

@@ -42 +42 @@
         getMyTree()->Branch("segmentedTrack", &m_segmentedTrack, "segmentedTrack/I");
         getMyTree()->Branch("clusterSize", &m_clusterSize, "clusterSize/I");
+        getMyTree()->Branch("clusterSize_X", &m_clusterSize_X, "clusterSize_X/I");
         getMyTree()->Branch("clusterHeight", &m_clusterHeight, "clusterHeight/I");
         getMyTree()->Branch("mipThetaAngle", &m_mipThetaAngle, "mipThetaAngle/D");
@@ -123 +124 @@
                         m_mipLength.push_back( totalLength ); // mm
                         m_mipLength_X.push_back( TMath::Abs ( limitPixels[__HEAD_INDX].first * m_pixSizeX
-                                        - limitPixels[__TAIL_INDX].first * m_pixSizeX ) );
+                                        - limitPixels[__TAIL_INDX].first * m_pixSizeX ) ); // [mm]
+                        m_clusterSize_X = TMath::Abs ( limitPixels[__HEAD_INDX].first - limitPixels[__TAIL_INDX].first ); // [pixels]
                         m_totalMIPsLength += totalLength;
                         Log << MSG::DEBUG << "Integrated mips length = " << m_totalMIPsLength << " [mm]" << endreq;
@@ -145 +147 @@
                         m_mipThetaAngle = (*blobsItr).GetBlobProperties().rotAngle;
 
-                        // check discontinuitis if any
-                        if ( MAFTools::FindDiscontinuity(*blobsItr) == 1 ) {
-                                m_segmentedTrack = 1;
-                        } else {
-                                m_segmentedTrack = 0;
-                        }
+                        // check discontinuities if any
+                        // For this I will run the clustering again with discontinuity tolerance = 0;
+                        int nInnerClusters = CheckDiscontinuity(*blobsItr, 0);
+                        m_segmentedTrack = nInnerClusters;
 
                         // Find the limit pixels to add-up the charge per column.
@@ -168 +168 @@
                         Log << MSG::INFO << "                            y:" << inity << " , " << endy << endreq;
 
-                        // some infor about this blob after clustering
+                        /*
+                        // Some info about this blob after clustering
                         // get the content set x,y
                         set< pair<Int_t, Int_t> > cs = (*blobsItr).GetContentSet();
@@ -177 +178 @@
                                                 << GetMatrixElement(*csItr) << endreq;
                         }
+                        */
 
                         m_clusterHeight = (*blobsItr).GetBlobProperties().width_y;
@@ -351 +353 @@
 }
 
+int ShallowAngleFEIX::CheckDiscontinuity(blob bl, int discontinuityTolerance){
+
+        // new object containing all the blobs, ready to go to StoreGate when's ready
+        AllBlobsContainer * reclusteringContainer = new AllBlobsContainer((MediPixAlgo *) this);
+        Log << MSG::INFO << "Reclustering container --> " << reclusteringContainer << endreq;
+
+        std::map<int,int> totmap = GetTOTMap();
+        MAFTools::DigitalBlobReclustering(discontinuityTolerance, reclusteringContainer, bl, GetMatrixWidth(), GetMatrixHeight(), totmap);
+
+        Log << MSG::INFO << "Reclustering ... found " << reclusteringContainer->GetBlobsVector().size() << " clusters in the blob" << endreq;
+
+        return reclusteringContainer->GetBlobsVector().size();
+}
+
 #endif

mafalda/ShallowAngleFEIX/ShallowAngleFEIX.h

@@ -19 +19 @@
 public:
 
-  ShallowAngleFEIX();
-  virtual ~ShallowAngleFEIX() { };
+        ShallowAngleFEIX();
+        virtual ~ShallowAngleFEIX() { };
 
-  // You ought to implement Init(), Execute() and Finalize()
-  //  when you inherit from MediPixAlgo.  This model gives you
-  //  direct access to data and services.
-  void Init();
-  void Execute();
-  void Finalize();
+        // You ought to implement Init(), Execute() and Finalize()
+        //  when you inherit from MediPixAlgo.  This model gives you
+        //  direct access to data and services.
+        void Init();
+        void Execute();
+        void Finalize();
 
-  vector<pair<Float_t, Float_t> > FindLimitPixels(blob);
-  Int_t GuessNumberOfDeltaRaysFromUnbalance(Int_t &, Int_t &);
+        vector<pair<Float_t, Float_t> > FindLimitPixels(blob);
+        Int_t GuessNumberOfDeltaRaysFromUnbalance(Int_t &, Int_t &);
+        int CheckDiscontinuity(blob, int);
 
 private:
 
-  AllBlobsContainer * m_aB;
-  Int_t m_minNPixels;
-  Int_t m_guardDistanceX;
-  Int_t m_guardDistanceY;
-  Float_t m_pixSizeX;
-  Float_t m_pixSizeY;
-  Float_t m_dRayBalSearch;
-  Int_t m_minXWidth;
+        AllBlobsContainer * m_aB;
+        Int_t m_minNPixels;
+        Int_t m_guardDistanceX;
+        Int_t m_guardDistanceY;
+        Float_t m_pixSizeX;
+        Float_t m_pixSizeY;
+        Float_t m_dRayBalSearch;
+        Int_t m_minXWidth;
 
-  // for output
-  vector<Float_t> m_distanceToCenter;
-  Int_t m_clusterSize;
-  vector<Float_t> m_mipLength;
-  vector<Float_t> m_mipLength_X;
-  Double_t m_totalMIPsLength;
-  Int_t m_clusterHeight;
-  Double_t m_mipThetaAngle;
-  Int_t m_segmentedTrack;
+        // for output
+        vector<Float_t> m_distanceToCenter;
+        Int_t m_clusterSize;
+        Int_t m_clusterSize_X;
+        vector<Float_t> m_mipLength;
+        vector<Float_t> m_mipLength_X;
+        Double_t m_totalMIPsLength;
+        Int_t m_clusterHeight;
+        Double_t m_mipThetaAngle;
+        Int_t m_segmentedTrack;
 
-  vector<Int_t> m_totPerSegment; // Total TOT per segment/pixel
-  vector<Float_t> m_chargeWeights; // Charge weight, normalized to the total TOT of the track
+        // Container for reclustering if needed
+        AllBlobsContainer * m_reclusteringContainer;
 
-  ClassDef(ShallowAngleFEIX, 1)
+        vector<Int_t> m_totPerSegment; // Total TOT per segment/pixel
+        vector<Float_t> m_chargeWeights; // Charge weight, normalized to the total TOT of the track
+
+        ClassDef(ShallowAngleFEIX, 1)
 };
 

mafalda/ShallowAngleFEIX/configuration_algos_ShallowAngleFEIX.txt

@@ -7 +7 @@
 ShallowAngleFEIX dRayBalSearch 1.4 float
 BlobsFinder border 0 int
-BlobsFinder discontinuity 0 int
+BlobsFinder discontinuity 1 int
 BlobsFinder lvl1cut -1 int
 PRBasicSpecies nInnerPixels 2 int

mafalda/ShallowAngleFEIX/runAngle.C

@@ -20 +20 @@
 
 
-  GetTree("/home/idarraga/storage/61548/slice1/MAFOutput_MPXNtuple_USBPIXI4_22.root",
-          "ShallowAngleFEIX", "Lub4", 1.0);
+  GetTree("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_USBPIXI4_23_61417.root",
+          "ShallowAngleFEIX", "61417 3D-SCC87 p-5E15", 1.0);
+
+    GetTree("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_USBPIXI4_22_61548.root",
+          "ShallowAngleFEIX", "61548 Planar-LUB4 n-5E15", 1.0);
 
   //GetTree("/storage1/idarraga/Testbeam_September_CERN_2011/KEK_20V_200V_4deg/MAFOutput/MAFOutput_MPXNtuple_USBPIXI4_21.root",
@@ -45 +48 @@
   opts.markerStyle = 3;
   opts.setLogY = false;
-  drawNormalized = false;
+  opts.drawNormalized = false;
 
   ActionFlags afl;
@@ -68 +71 @@
   opts.doLegend = true;
   opts.constructorStr = "(40,0,5)";
-  TH1 * h_first = (TH1 *) DrawAll("mipLength_X", "", opts, afl);
+  TH1 * h_first = (TH1 *) DrawAll("mipLength_X", "clusterHeight < 3 && TMath::Abs(mipThetaAngle) < 0.17", opts, afl);
   //h_first->GetXaxis()->SetRangeUser(0, 10);
   h_first->GetXaxis()->SetTitle("mip length [mm]");

mafalda/ShallowAngleFEIX/runNewAlgo.C

@@ -17 +17 @@
         TChain * T1 = new TChain("ShallowAngleFEIX");
 
-        T1->Add("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_USBPIXI4_23.root");
-        TString titleT = "3D SCC87";
+        T1->Add("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_USBPIXI4_23_61417.root");
+        TString titleT = "";
 
         //T1->Add("/home/idarraga/storage/61548/slice1/MAFOutput_MPXNtuple_USBPIXI4_22.root");
@@ -36 +36 @@
         TCanvas * c10 = new TCanvas();
 
-        TGraphErrors * g1 = GetGraph(T1, "planar", ndiv, fulldiv, plotType);
+        TGraphErrors * g1 = GetGraph(T1, "3D", 7, 7, plotType);
         c10->cd();
         g1->Draw("A*");
@@ -49 +49 @@
         lt1->DrawLatex(0.050, 9, "backside");
         lt1->DrawLatex(0.050, 13, "frontside");
-        lt1->DrawLatex(0.06, 4, titleT);
+        //lt1->DrawLatex(0.06, 4, titleT);
 
         TLatex * lt2 = new TLatex();
@@ -55 +55 @@
         lt2->DrawLatex(0.06, 1, "MAFalda, idarraga@cern.ch");
 
-        return;
-
         /////////////////////////////////////////////////////////////////////////////////////
 
         TChain * T2 = new TChain("ShallowAngleFEIX");
-        T2->Add("/storage1/idarraga/Testbeam_July_CERN_2011/KEK_100V_4deg/MAFOutput/MAFOutput_MPXNtuple_USBPIXI4_21_100V.root");
+        T2->Add("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_USBPIXI4_22_61548.root");
         //T2->Add("/home/idarraga/analysis/mafalda/MAFOutput_MPXNtuple_AllPix_det_200_shallowAngle_3D.root");
 
-        TGraphErrors * g2 = GetGraph(T2, "3D", 10, fulldiv, plotType);
+        TGraphErrors * g2 = GetGraph(T2, "Planar", 6, 6, plotType);
         // fix last point
         c10->cd();
@@ -73 +71 @@
         /////////////////////////////////////////////////////////////////////////////////////
         TLegend * l1 = new TLegend(0.5, 0.7, 0.9, 0.9);
-        l1->AddEntry(g1, "Planar Simulation", "P");
-        l1->AddEntry(g2, "Planar real data", "P");
+        l1->AddEntry(g1, "61417 3D-SCC87 p-5E15", "P");
+        l1->AddEntry(g2, "61548 Planar-LUB4 n-5E15", "P");
         l1->Draw();
         l1->SetBorderSize(1);
@@ -111 +109 @@
 
         int partitionCntr = 0;
-        for (int indx = __NDIV-1 ; indx >= 0 ; indx--) {
-        //for (indx = 0 ; indx < __NDIV ; indx++) {
+        //for (int indx = __NDIV-1 ; indx >= 0 ; indx--) {
+        for (int indx = 0 ; indx < __NDIV ; indx++) {
 
                 wordDraw = "totPerSegment[";
@@ -130 +128 @@
                 c1->cd(indx+1);
                 TString cutS = "clusterHeight < 3 ";
-                cutS += " && clusterSize == ";
+                cutS += " && clusterSize_X == ";
                 cutS += __NDIV;
-                cutS += " && mipThetaAngle < 0.17"; // ~10 deg
+                cutS += " && TMath::Abs(mipThetaAngle) < 0.17"; // ~10 deg
                 TCut cutC = cutS;
                 T->Draw(wordDraw, cutC);