Changeset 12259 for fact/tools/rootmacros

Timestamp:

10/25/11 13:52:10 (13 years ago)

Author:

neise

Message:

discriminator does now return vector<Region>

Location:

fact/tools/rootmacros

Files:

• discriminator.C (modified) (3 diffs)
• discriminator.h (modified) (1 diff)

fact/tools/rootmacros/discriminator.C

@@ -4 +4 @@
 
 // this function reads a (hopefully smoothed, and baseline corrected) DRS pipeline and produces 
-// three vectors 
-// 1. start of 'over threshold'
-// 2. end of 'over threshold'
-// 3. max within this 'over threshold' region
+// The DRs pipiline is given as a vector<float>. 
+//
+// the Output is a vector of Over-Threshold-Regions, which are described by 
+//      * the index of its start
+//      * the index of its Maximum
+//      * the index of its end
+//      * the height of its Maximum
 //
 // it needs a threshold and the length of the falling edge 
@@ -13 +16 @@
 #include "discriminator.h"
 
-vector<DiscOut> * discriminator(
-                vector<float>& input,                   // vector of floats, the discriminator acts on
-                float thr = 5.,                                                 // threshold
-                int fallingEdge = 100   )                       // number of slices, after the maximum, which should be discarded...
-{
+vector<Region> * discriminator(
+        vector<float>& input,           // vector of floats, the discriminator acts on
+        float thr,                                      // threshold
+        bool clean,                                     // choose here, if the discriminator should already discard Regions, which are assumend to sit on the predessesors falling edge
+        int fallingEdge,                        // number of slices, after the maximum, which should be discarded...
+        bool debug
+){ //----- start of function discrimnator--------
 
-        vector<DiscOut> * result = new vector<DiscOut>;
-        DiscOut disc;
-        disc.begin = 0;
-        disc.end = 0;
-        disc.maxPos = 0;
-        disc.maxVal = 0.;
-        bool start_under_thr = false;
+        // this vector will contain the Region, found by the simple 
+        // discriminator 
+        vector<Region> * uncleaned = new vector<Region>;
+
+        // The former vector will be cleaned, by checking the distance of the 
+        // position of the Maxima .... Maxima, sitting on 
+        // falling edges of other pulses, should be discarded.
+        vector<Region> * Cleaned = new vector<Region>;
+        
+        Region currentRegion;
+        currentRegion.begin = 0;
+        currentRegion.end = 0;
+        currentRegion.maxPos = 0;
+        currentRegion.maxVal = 0.;
         bool over_thr_found = false;
 
+        for ( unsigned int sl = 0; sl < input.size() ; sl++ ){
+                if ( input[sl] > thr ) {
+                        // mark as -start-
+                        if ( !over_thr_found ) {
+                                over_thr_found = true;
+                                currentRegion.begin = sl;
+                        }
 
-        bool debug = false; // switch to true in order to generate some output.
+                        // Find the -Maximum- in this Region
+                        if ( input[sl] > currentRegion.maxVal) {
+                                currentRegion.maxVal = input[sl];
+                                currentRegion.maxPos = sl;
+                        }
 
-        for ( int sl = 0; sl < input.size() ; sl++ ){
+                } else if ( input[sl] < thr ) {
 
-
-                        if ( input[sl] > thr ) {
-                                
-                                if ( !over_thr_found ) {
-                                        over_thr_found = true;
-                                        disc.begin = sl;
-                                }
-
-                                if ( input[sl] > disc.maxVal) {
-                                        disc.maxVal = input[sl];
-                                        disc.maxPos = sl;
-                                }
+                        // mark the -end- 
+                        if ( over_thr_found ) {
+                                over_thr_found = false;
+                                currentRegion.end = sl;
+                                // store the region in a vector.        
+                                uncleaned->push_back(currentRegion);
+                                currentRegion.begin = 0;
+                                currentRegion.end = 0;
+                                currentRegion.maxPos = 0;
+                                currentRegion.maxVal = 0.;
                         }
-                        if ( input[sl] < thr ) {
-                                if ( over_thr_found ) {
-                                        over_thr_found = false;
-                                        disc.end = sl;
-                                
-                                        result->push_back(disc);
-                                        disc.begin = 0;
-                                        disc.end = 0;
-                                        disc.maxPos = 0;
-                                        disc.maxVal = 0.;
-
-                                }
-                        }               
-        } // end of for llop over all slices
+                }               
+        } // end of for loop over all slices
 
                 if (debug){  // output the vector
-                        for (int p=0; p<result->size(); p++ ){
+                        cout << "------------Discriminator Debug Output:"
+                                        <<"----------------" << endl;
+                        cout << "\t uncleaned Over Threshold Regions found: "
+                                        << uncleaned->size() << endl;
+                        for (unsigned int p=0 ; p < uncleaned->size() ; p++ ){
                                 cout << p << ":\t"; 
-                                cout << result->at(p).begin << "\t";
-                                cout << result->at(p).end << "\t";
-                                cout << result->at(p).maxPos << "\t";
-                                cout << result->at(p).maxVal << endl;
+                                cout << uncleaned->at(p).begin << "\t";
+                                cout << uncleaned->at(p).end << "\t";
+                                cout << uncleaned->at(p).maxPos << "\t";
+                                cout << uncleaned->at(p).maxVal << endl;
                         }
                 }
 
-DiscOut last;
-vector<DiscOut> * realresult = new vector<DiscOut>;
-        
-if (result->size() > 0) {       
-        while (!result->empty()){
+        if (clean){
+                cleanRegionsOnFallingEdge ( *Cleaned, *uncleaned, fallingEdge, debug);
+                delete uncleaned;
+                return Cleaned;
+        } else
+                return uncleaned;
 
-                last.begin = result->back().begin;
-                last.end = result->back().end;
-                last.maxPos = result->back().maxPos;
-                last.maxVal = result->back().maxVal;
-                result->pop_back();
 
-                if (result->empty()){
-                        if (last.maxPos > 0)
-                                realresult->push_back(last);
+
+
+} // end of function - discriminator
+///////////////////////////////////////////////////////////////////////////////////////
+
+
+
+
+////////// Cleaning Funcs ////////////
+
+int     cleanRegionsOnFallingEdge ( 
+                vector<Region> &dest,
+                vector<Region> &src,
+                int fallingEdgeLen, 
+                bool debug
+){
+        // This function scans the src-vector for Maxima, sitting on its predesessors falling edge.
+        // the out vector is cleaned from these regions. 
+        // note: the cleaned regions are appended to the dest-vector.
+        //
+        //
+        // note further: in case pulses pile up to form a broad Region over threshold
+        // the maximum of this region is caused by pile up, even though is is far away from the next region.
+        // TODO
+        // write another cleaning function - or implement into this function a check, 
+        // if the maximum the first of all local maxima in the region.
+        // maybe the search for the maximum should be oursourced and not be done in the first 
+        // discrimnator loop in line 51ff...
+
+        if (dest.size() > 0 && debug)
+                cout << "discriminator::cleanRegionsOnFallingEdge: destination vector.size()=" << dest.size() << endl;
+
+        // if nothing to do
+        if (src.size() == 0){
+                if (debug)
+                        cout << "discriminator::cleanRegionsOnFallingEdge: src vector empty" << endl;
+                return -1;                      
+        }
+
+        // local copy of source
+        vector<Region> localSrc(src);
+        // last Region in (local)-src
+        Region last;
+        while (!localSrc.empty()){
+                last = localSrc.back();
+                localSrc.pop_back();
+                                //              last.begin = result->back().begin;
+                                //              last.end = result->back().end;
+                                //              last.maxPos = result->back().maxPos;
+                                //              last.maxVal = result->back().maxVal;    
+
+                // if localSrc is _now_ empty, then there was no predecessor
+                if (localSrc.empty()){
+                        dest.push_back(last);
                         break;
                 }
-                if (last.maxPos - result->back().maxPos > fallingEdge)
-                        realresult->push_back(last);
+                if (last.maxPos - localSrc.back().maxPos > fallingEdgeLen)
+                        dest.push_back(last);
         }
+
+                if (debug){  // output the vector
+                        cout << "------------Discriminator::CleanRegionsOnFallingEdge -  Debug Output:----------------" << endl; 
+                        cout << "\t Cleaned Regions found: " << dest.size() << endl; 
+                        for (unsigned int p=0 ; p < dest.size() ; p++ ){
+                                cout << p << ":\t"; 
+                                cout << dest.at(p).begin << "\t";
+                                cout << dest.at(p).end << "\t";
+                                cout << dest.at(p).maxPos << "\t";
+                                cout << dest.at(p).maxVal << endl;
+                        }
+                }
+
+return 0;
 }
+ 
+//////  alternative loop, but it didn't work ////////////////
 /*
         vector<vector<DiscOut>::iterator> toBeDeleted;
@@ -111 +187 @@
 */
 
-delete result;
-return realresult;
 
-} // end of function - discriminator
+

fact/tools/rootmacros/discriminator.h

@@ +1 @@
+// file: discriminator.h
 
-        #ifndef __DISCRIMINATOR_H
-        #define __DISCRIMINATOR_H
+#ifndef __DISCRIMINATOR_H
+#define __DISCRIMINATOR_H
 
-        typedef struct
-        {
-                int begin;
-          int maxPos;
-          int end;
-          float maxVal;
-        }
-        DiscOut;
+#include "Region.h"
+
+#include <vector>
+
+std::vector<Region> * discriminator(
+        std::vector<float>& input,       // vector of floats, the discriminator acts on
+    float thr = 5.,             // threshold
+    bool clean = true,          // choose here, if the discriminator should already discard Regions, which are assumend to sit on the predessesors falling edge
+    int fallingEdge = 100,      // number of slices, after the maximum, which should be discarded...  
+    bool debug = false
+);
+
+int cleanRegionsOnFallingEdge (
+        std::vector<Region> &dest,
+        std::vector<Region> &src,
+    int fallingEdgeLen = 100,
+    bool debug = false);
         
 
-        #endif
-
+#endif