source: fact/tools/rootmacros/zerosearch.C@ 12426

#include "Region.h"
#include <vector>

// searches for zero crossings in a given vector of floats
// for zero crossings in falling edge 
// give edge = -1
// 
// 
// returns pointer to vetctor of ints

vector<Region> *zerosearch(
        vector<float> &input,
        int edge,                       // search for transitions on rising edge=1, -1:falling
        unsigned int step,                      // search in steps of step
        int VerbosityLevel
){

vector<Region> * ZeroPositions = new vector<Region>;
Region currentRegion = {0, 0, 0, 0.0};
        if (step < 1){
                if (VerbosityLevel > 0)
                        cout << "zerosearch - stepsize=" << step
                                << " is smaller than 1. returning." << endl;
                return ZeroPositions;
        }
        if (input.size() < step){
                if (VerbosityLevel > 0)
                        cout << "zerosearch - input-vector.size()="<< input.size()
                        << " is smaller than stepsize=" << step
                        << "returning." << endl;
                return ZeroPositions;
        }
        
        if (edge > 0) // search for zero-x-ings on the rising edge
        {
                for (unsigned int sl = 0 ; sl < (input.size()-step) ; sl+=step)
                {
                        if (input[sl] > 0.0) // can't be a rising 0-x-ing
                        {
                                continue;
                        }
                        if (input[sl] * input[sl+step] <= 0.0)  // 0-x-ing or both are 0
                        {
                                currentRegion.begin     = sl;
                                currentRegion.end       = sl+step;
                                ZeroPositions->push_back(currentRegion);
                        }
                }
        }
        else if (edge < 0) // search for zero-x-ings on the falling edge
        {
                for (unsigned int sl = 0 ; sl < (input.size()-step) ; sl+=step)
                {
                        if (input[sl] < 0.0) // can't be a falling 0-x-ing
                        {
                                continue;
                        }
                        if (input[sl] * input[sl+step] <= 0.0)  // 0-x-ing or both are 0
                        {
                                currentRegion.begin     = sl;
                                currentRegion.end       = sl+step;
                                ZeroPositions->push_back(currentRegion);
                        }
                }

        }
        else // search for zero-x-ings on both esges
        {
                for (unsigned int sl = 0 ; sl < (input.size()-step) ; sl+=step)
                {
                        if (input[sl] * input[sl+step] <= 0.0)  // 0-x-ing or both are 0
                        {
                                currentRegion.begin     = sl;
                                currentRegion.end       = sl+step;
                                ZeroPositions->push_back(currentRegion);
                        }
                }
        }

        
        return ZeroPositions;
}

size_t ShiftRegionBy(vector<Region> &src,
        int Shift,
        int VerbosityLevel)
{
vector<Region>::iterator it;
        // I copy code here ... not good, but I hope nobody is giving VL > 10 ever...
        if (VerbosityLevel > 10){
                for (it = src.begin() ; it < src.end() ; it++){
                        cout << " it->begin="<< it->begin;
                        it->begin += Shift;
                        cout << "--> shifted="<< it->begin << endl;
                        cout << " it->end="<< it->end;
                        it->end += Shift;
                        cout << "--> shifted="<< it->end << endl;
                        cout << " it->maxPos="<< it->maxPos;
                        it->maxPos += Shift;
                        cout << "--> shifted="<< it->maxPos << endl;
                }
                return src.size();
        }

        for (it = src.begin() ; it < src.end() ; it++){
                it->begin += Shift;
                it->end += Shift;
                it->maxPos += Shift;
        }
        return src.size();
}

size_t EnlargeRegion(vector<Region> &src,
        int Left,
        int Right,
        int VerbosityLevel)
{
vector<Region>::iterator it;
        // I copy code here ... not good, but I hope nobody is giving VL > 10 ever...
        if (VerbosityLevel > 10){
                for (it = src.begin() ; it < src.end() ; it++){
                        cout << " it->begin="<< it->begin;
                        it->begin -= Left;
                        cout << "--> enlarged="<< it->begin << endl;
                        cout << " it->end="<< it->end;
                        it->end += Right;
                        cout << "--> enlarged="<< it->end << endl;
                }
                return src.size();
        }


                for (it = src.begin() ; it < src.end() ; it++){
                it->begin -= Left;
                it->end += Right;
        }
        return src.size();

}

#include <limits>
size_t findAbsMaxInRegions(
        vector<Region> &regions,
        vector<float> &data,
        int VerbosityLevel)
{
vector<Region>::iterator reg;
        for (reg = regions.begin() ; reg < regions.end() ; reg++){
                reg->maxVal=-numeric_limits<float>::max();
                // 1st check if both ends of the region are in the data-vector
                if (reg->begin < 0) reg->begin=0;
                if ((unsigned int)reg->end > data.size()-1) reg->end=data.size()-1;

                // TODO or TOTHINKOF:
                // Region might overlap ... I don't care .. I just search
                // in a later step Maxima at the same Positions can be removed...
                // of course this means, some searches were needless ...
                //cout << "searching from " << reg->begin << " to " << reg->end << endl;
                for (unsigned int pos=reg->begin; pos <= (unsigned int)reg->end; pos++){
                        if (data[pos] > reg->maxVal){
                                reg->maxVal = data[pos];
                                reg->maxPos = pos;
                        }
                }
                if (VerbosityLevel > 3) {
                        cout << "findAbsMaxInRegions - found Max at:"
                                << reg->maxPos << " with Value:" << reg->maxVal << endl;
                }
        }
        return regions.size();
}

#include <algorithm>
bool compMaxPosOfRegions (Region a, Region b) {
  return (a.maxPos == b.maxPos);
}

size_t removeEqualMaxima(
        vector<Region> &regions,
        int VerbosityLevel)
{
        if (VerbosityLevel > 2){
                cout << "removeEqualMaxima:" << endl;
                cout << "region before contains:" << endl;
                for (unsigned int i=0; i<regions.size(); i++){
                        cout << i <<"\t";
                        cout << regions[i].begin <<"\t";
                        cout << regions[i].end <<"\t";
                        cout << regions[i].maxPos <<"\t";
                        cout << regions[i].maxVal <<"\t";
                        cout << endl;
                }
        }

        vector<Region>::iterator it;
        it = unique (regions.begin(), regions.end() , compMaxPosOfRegions);
        regions.resize( it - regions.begin() );

        if (VerbosityLevel > 1){
                cout << "region now contains:" << endl;
                for (unsigned int i=0; i<regions.size(); i++){
                        cout << i <<"\t";
                        cout << regions[i].begin <<"\t";
                        cout << regions[i].end <<"\t";
                        cout << regions[i].maxPos <<"\t";
                        cout << regions[i].maxVal <<"\t";
                        cout << endl;
                }
        }
        return regions.size();
}

size_t removeRegionOnFallingEdge(
        vector<Region> &regions,
        unsigned int FallingEdgeWidth,
        int VerbosityLevel)
{
if ( FallingEdgeWidth < 1){
    if (VerbosityLevel > 0){
      cout << " removeRegionOnFallingEdge: FallingEdgeWidth  < 1" << endl;
      cout << " FallingEdgeWidth =" << FallingEdgeWidth << endl;
      cout << "returning." << endl;
    return regions.size();
    }
  }
        if (regions.size() < 1){
                if (VerbosityLevel > 3)
                        cout << "removeRegionOnFallingEdge: source vector empty." << endl;
                return 0;
        }

 vector<Region>::reverse_iterator it = regions.rbegin();
  while( it != regions.rend()-1 )
  {
  if (VerbosityLevel >10)
                cout << it->maxPos << "\t" << (it+1)->maxPos << "\t" << it->maxPos - (it+1)->maxPos << endl; 

    if ( it->maxPos - (it+1)->maxPos < (int)FallingEdgeWidth) {
      if (VerbosityLevel > 3)
        cout << "erasing Region @ " << it->maxPos << endl;
       regions.erase( --it.base() ) ;
      ++it;
    }else
      ++it;
  }

  return regions.size();
}


size_t removeRegionWithMaxOnEdge(
        vector<Region> &regions,
        unsigned int EdgeWidth,
        int VerbosityLevel)
{
        if (EdgeWidth < 1){
                if (VerbosityLevel > 0){
                        cout << "removeReginWithMaximaOnEdge: EdgeWidth < 1" << endl;
                        cout << "EdgeWidth=" << EdgeWidth << endl;
                        cout << "returning." << endl;
                return regions.size();
                }
        }

        vector<Region>::iterator it = regions.begin();
        while( it != regions.end() )
        {
//      cout << it->begin << "\t";
//      cout << it->maxPos << "\t";
//      cout << it->end << "\t";
//      cout << it->maxVal << endl;

                if (it->maxPos < (int)(it->begin+EdgeWidth)) {
                        if (VerbosityLevel > 3)
                                cout << "erasing Region(max@left edge) " << it->maxPos << endl;
                        it = regions.erase( it ) ;
                        //++it;
                }else if (it->maxPos > (int)(it->end-EdgeWidth)) {
                        if (VerbosityLevel > 3)
                                cout << "erasing Region(max@right edge) " << it->maxPos << endl;
                        it = regions.erase( it ) ;
                        //++it;
                }else
                        ++it;

        }

        return regions.size();
}

size_t removeMaximaBelow(
        vector<Region> &regions,
        float threshold,
        int VerbosityLevel)
{
        if (threshold < 0){
                if (VerbosityLevel > 0)
                        cout << "removeMaximaBelow: threshold < 0" << endl;
                        cout << "threshold=" << threshold << endl;
                        cout << "returning." << endl;
                return regions.size();
        }

        vector<Region>::iterator it = regions.begin();
        while( it != regions.end() )
        {
                if (it->maxVal < threshold ) {
                        if (VerbosityLevel > 3){
                                cout << "removing max " << it->maxVal << "\t";
                                cout << " @ " << it->maxPos << "\t";
                                cout << endl;
                        }
                        it = regions.erase( it ) ;
                }else
                        ++it;
        }

        return regions.size();
}

size_t removeMaximaAbove(
        vector<Region> &regions,
        float threshold,
        int VerbosityLevel)
{
        if (threshold < 0){
                if (VerbosityLevel > 0)
                        cout << "removeMaximaAbove: threshold < 0" << endl;
                        cout << "threshold=" << threshold << endl;
                        cout << "returning." << endl;
                return regions.size();
        }

        vector<Region>::iterator it = regions.begin();
        while( it != regions.end() )
        {
                if (it->maxVal > threshold ) {
                        if (VerbosityLevel > 3){
                                cout << "removing max " << it->maxVal << "\t";
                                cout << " @ " << it->maxPos << "\t";
                                cout << endl;
                        }
                        it = regions.erase( it ) ;
                }else
                        ++it;
        }

        return regions.size();
}

Region FindAbsMax(
        vector<Region> &regions,
        int VerbosityLevel)
{
        Region AbsMax;
        AbsMax.begin = -1;
        AbsMax.maxPos = -1;
        AbsMax.end = -1;
        AbsMax.maxVal=-numeric_limits<float>::max();
        if (regions.size() < 1)
                return AbsMax;

        for (vector<Region>::iterator it = regions.begin(); it < regions.end(); ++it)
        {
                if (it->maxVal > AbsMax.maxVal ) {
                        AbsMax = *it;
                }
        }
        return AbsMax;
}

////////////////
////////////// old Version of the code
/*
        for (unsigned int sl = step; sl < input.size(); sl+=step){
                if (input[sl] * input[sl-] < 0 || input[sl]==0.0 ){ // sign change --> zero crossing OR really zero

                        if ( (input[sl-1] - input[sl]) * edge < 0){ // this is the crossing the user wanted

                                // check if we go lower than a certain limit in the next few slices
                                for ( int lala=0; lala<post; lala++){
                                        if (input[sl+lala] > 1.5) {
                                                zeroPositions->push_back(sl);
                                                sl += lala;
                                                break;
                                        }
                                }

                        } else if ( (input[sl-1] - input[sl]) * edge > 0){ // this is the zero x-ing the user did not want

                                // do nothing

                        } else { // sl and sl-1 are equal .. don't know waht do to...

                        }

                }

        } // end of loop over slices - between pre and post

*/