BmnVSPLayer.cxx

Go to the documentation of this file.

#include "BmnVSPLayer.h"
 
#include "TMath.h"
 
#include <iostream>
 
using namespace TMath;
using namespace std;
 
Int_t BmnVSPLayer::fUniqueIdL = 0;
Int_t BmnVSPLayer::fUniqueIdU = 0;
 
BmnVSPLayer::BmnVSPLayer() {
 
    Verbosity = true;
 
    ZoneID = -1;
    LayerType = LowerStripLayer;
    FirstStripNumber = 0;
 
    XMinLayer = 0.0;
    XMaxLayer = 10.0;
    YMinLayer = 0.0;
    YMaxLayer = 10.0;
 
    Pitch = 0.01; //cm
    AngleDeg = 2.5; //in degrees from a vertical line where a plus value is clockwise
    AngleRad = AngleDeg*Pi()/180; //in radians
 
    StripOrder = LeftToRight;
 
    if(AngleDeg <= 0.0 && AngleDeg >= -90.0) {
        SetStripNumberingBorders(LeftBottom, RightTop);
    }
    else {
        if(AngleDeg > 0.0 && AngleDeg <= 90.0) {
            SetStripNumberingBorders(LeftTop, RightBottom);
        }
    }
 
    ClusterFindingThreshold = 0.0;
 
    InitializeLayer();
}
 
BmnVSPLayer::BmnVSPLayer(Int_t zone_id,
                                 StripLayerType layer_type, Int_t first_strip_number,
                                 Double_t xsize, Double_t ysize,
                                 Double_t xorig, Double_t yorig,
                                 Double_t pitch, Double_t adeg) {
 
    Verbosity = true;
 
    ZoneID = zone_id;
    LayerType = layer_type;
    FirstStripNumber = first_strip_number;
 
    XMinLayer = xorig;
    XMaxLayer = xorig + xsize;
    YMinLayer = yorig;
    YMaxLayer = yorig + ysize;
 
    Pitch = pitch;
    AngleDeg = adeg; //in degrees from a vertical line where a plus value is clockwise
    AngleRad = AngleDeg*Pi()/180; //in radians
 
    StripOrder = LeftToRight;
 
    if(AngleDeg <= 0.0 && AngleDeg >= -90.0) {
        SetStripNumberingBorders(LeftBottom, RightTop);
    }
    else {
        if(AngleDeg > 0.0 && AngleDeg <= 90.0) {
            SetStripNumberingBorders(LeftTop, RightBottom);
        }
    }
 
    ClusterFindingThreshold = 0.0;
 
    InitializeLayer();
}
 
BmnVSPLayer::~BmnVSPLayer() {
 
}
 
void BmnVSPLayer::InitializeLayer() {
    Int_t NStrips = GetNStrips();
 
    //strips
    Strips.clear();
    Strips.resize(NStrips, 0.0);
 
    //matches
    ResetStripMatches();
    ResetStripDigitNumberMatches();
 
    //strip hits
    ResetStripHits();
 
    BmnVSPLayer::fUniqueIdL = 0;
    BmnVSPLayer::fUniqueIdU = 0;
}
 
void BmnVSPLayer::ResetLayer() {
    InitializeLayer();
}
 
Int_t BmnVSPLayer::GetNStrips() {
    Double_t xleft_layer = ConvertNormalPointToStripX(XLeftPointOfStripNumbering, YLeftPointOfStripNumbering);
    Double_t xright_layer = ConvertNormalPointToStripX(XRightPointOfStripNumbering, YRightPointOfStripNumbering);
    Double_t n_strips = (xright_layer - xleft_layer)/Pitch;
 
//    if( (n_strips - (Int_t)n_strips) < 1E-10 ) {
//        return (Int_t)n_strips;
//    }
//    else {
//        return (Int_t)(n_strips+1);
//    }
 
    //
    return (Int_t)n_strips;
}
 
void BmnVSPLayer::SetPitch(Double_t pitch) {
    Pitch = pitch;
 
    InitializeLayer();
}
 
void BmnVSPLayer::SetLayerSizes(Double_t xsize, Double_t ysize, Double_t xorig, Double_t yorig) {
    XMinLayer = xorig;
    XMaxLayer = xorig + xsize;
    YMinLayer = yorig;
    YMaxLayer = yorig + ysize;
 
    InitializeLayer();
}
 
void BmnVSPLayer::SetAngleDeg(Double_t deg) {
    if(Abs(deg) <= 90.0) {
         AngleDeg = deg;
    }
    else {
        AngleDeg = 0.0;
        if(Verbosity) cerr << "WARNING: BmnVSPLayer::SetAngleDeg(): the strip angle is incorrect and has been set to zero\n";
    }
 
    AngleRad = AngleDeg*Pi()/180;
 
    InitializeLayer();
}
 
Bool_t BmnVSPLayer::SetStripNumberingBorders(Double_t x_left, Double_t y_left, Double_t x_right, Double_t y_right) {
    if(x_right < x_left) return false;
 
    XLeftPointOfStripNumbering = x_left;
    YLeftPointOfStripNumbering = y_left;
    XRightPointOfStripNumbering = x_right;
    YRightPointOfStripNumbering = y_right;
 
    ResetLayer();
 
    return true;
}
 
Bool_t BmnVSPLayer::SetStripNumberingBorders(StripBorderPoint left, StripBorderPoint right) {
 
    if( left != LeftTop && left != LeftBottom )  {
        if(Verbosity) cerr << "WARNING: SetStripNumberingBorders: left strip border point is incorrect\n";
        return false;
    }
    if( right != RightTop && right != RightBottom ) {
        if(Verbosity) cerr << "WARNING: SetStripNumberingBorders: right strip border point is incorrect\n";
        return false;
    }
 
    XLeftPointOfStripNumbering = XMinLayer;
    XRightPointOfStripNumbering = XMaxLayer;
 
    switch (left) {
        case LeftTop:
            YLeftPointOfStripNumbering = YMaxLayer;
            break;
        case LeftBottom:
            YLeftPointOfStripNumbering = YMinLayer;
            break;
        default:
            return false;
    }
 
    switch (right) {
        case RightTop:
            YRightPointOfStripNumbering = YMaxLayer;
            break;
        case RightBottom:
            YRightPointOfStripNumbering = YMinLayer;
            break;
        default:
            return false;
    }
 
    ResetLayer();
 
    return true;
}
 
Bool_t BmnVSPLayer::SetStripNumberingOrder(StripNumberingDirection strip_direction) {
    StripOrder = strip_direction;
 
    ResetLayer();
 
    return true;
}
 
Bool_t BmnVSPLayer::AddDeadZone(Int_t n_points, Double_t *x_points, Double_t *y_points) {
    DeadZoneOfStripLayer dead_zone;
    Bool_t status = dead_zone.SetDeadZone(n_points, x_points, y_points);
    if(status == true) {
        DeadZones.push_back(dead_zone);
        return true;
    }
    else {
        return false;
    }
}
 
Bool_t BmnVSPLayer::AddDeadZone(DeadZoneOfStripLayer dead_zone) {
    if(dead_zone.GetNPoints() > 2) {
        DeadZones.push_back(dead_zone);
        return true;
    }
    else {
        return false;
    }
}
 
Bool_t BmnVSPLayer::IsPointInsideDeadZones(Double_t x, Double_t y) {
    for(size_t izone = 0; izone < DeadZones.size(); ++izone) {
        if(DeadZones[izone].IsInside(x,y)) return true;
    }
 
    return false;
}
 
Bool_t BmnVSPLayer::IsPointInsideStripLayer(Double_t x, Double_t y) {
    if( x >= XMinLayer && x <= XMaxLayer &&
        y >= YMinLayer && y <= YMaxLayer &&
        !IsPointInsideDeadZones(x, y) ) return true;
    else
        return false;
}
 
Bool_t BmnVSPLayer::SetStripSignal(Int_t strip_num, Double_t signal) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(Strips.size()+FirstStripNumber))
    {
        Strips[strip_num-FirstStripNumber] = signal;
        return true;
    }
    else return false;
}
 
Bool_t BmnVSPLayer::AddStripSignal(Int_t strip_num, Double_t signal) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(Strips.size()+FirstStripNumber))
    {
        Strips[strip_num-FirstStripNumber] += signal;
        return true;
    }
    else return false;
}
 
Double_t BmnVSPLayer::GetStripSignal(Int_t strip_num) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(Strips.size()+FirstStripNumber))
    {
        return Strips[strip_num-FirstStripNumber];
    }
    else return -1;
}
 
Bool_t BmnVSPLayer::SetStripMatch(Int_t strip_num, BmnMatch mc_match) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripMatches.size()+FirstStripNumber))
    {
        StripMatches[strip_num-FirstStripNumber] = mc_match;
        return true;
    }
    else return false;
}
 
Bool_t BmnVSPLayer::AddLinkToStripMatch(Int_t strip_num, Double_t weight, Int_t mc_num) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripMatches.size()+FirstStripNumber))
    {
        StripMatches[strip_num-FirstStripNumber].AddLink(weight, mc_num);
        return true;
    }
    else return false;
}
 
Bool_t BmnVSPLayer::SetStripDigitNumberMatch(Int_t strip_num, BmnMatch digit_num_match) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripDigitNumberMatches.size()+FirstStripNumber))
    {
        StripDigitNumberMatches[strip_num-FirstStripNumber] = digit_num_match;
        return true;
    }
    else return false;
}
 
Bool_t BmnVSPLayer::AddLinkToStripDigitNumberMatch(Int_t strip_num, Double_t weight, Int_t digit_num) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripDigitNumberMatches.size()+FirstStripNumber))
    {
        StripDigitNumberMatches[strip_num-FirstStripNumber].AddLink(weight, digit_num);
        return true;
    }
    else return false;
}
 
BmnMatch BmnVSPLayer::GetStripMatch(Int_t strip_num) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripMatches.size()+FirstStripNumber))
    {
        return StripMatches[strip_num-FirstStripNumber];
    }
    else return BmnMatch(); //return an empty match
}
 
BmnMatch BmnVSPLayer::GetStripDigitNumberMatch(Int_t strip_num) {
    if (strip_num >= FirstStripNumber && strip_num < (Int_t)(StripDigitNumberMatches.size()+FirstStripNumber))
    {
        return StripDigitNumberMatches[strip_num-FirstStripNumber];
    }
    else return BmnMatch(); //return an empty match
}
 
void BmnVSPLayer::ResetStripMatches() {
    Int_t NStrips = GetNStrips();
 
    StripMatches.clear();
    StripMatches.resize(NStrips, BmnMatch());
}
 
void BmnVSPLayer::ResetStripDigitNumberMatches() {
    Int_t NStrips = GetNStrips();
 
    StripDigitNumberMatches.clear();
    StripDigitNumberMatches.resize(NStrips, BmnMatch());
}
 
Double_t BmnVSPLayer::GetStripHitPos(Int_t num) {
    if(num >= 0 && num < (Int_t)StripHits.size()) {
        return StripHits[num];
    }
    return -1.0;
}
 
Double_t BmnVSPLayer::GetStripHitTotalSignal(Int_t num) {
    if(num >= 0 && num < (Int_t)StripHitsTotalSignal.size()) {
        return StripHitsTotalSignal[num];
    }
    return -1.0;
}
 
Double_t BmnVSPLayer::GetStripHitError(Int_t num) {
    if(num >= 0 && num < (Int_t)StripHitsErrors.size()) {
        return StripHitsErrors[num];
    }
    return -1.0;
}
 
Int_t BmnVSPLayer::GetStripHitClusterSize(Int_t num) {
    if(num >= 0 && num < (Int_t)StripHitsClusterSize.size()) {
        return StripHitsClusterSize[num];
    }
    return -1.0;
}
 
void BmnVSPLayer::ResetStripHits() {
    StripHits.clear();
    StripHitsTotalSignal.clear();
    StripHitsErrors.clear();
    StripHitsClusterSize.clear();
    StripClusters.clear();
}
 
Double_t BmnVSPLayer::ConvertNormalPointToStripX(Double_t x, Double_t y) {
    Double_t XRotationCenter;
    Double_t YRotationCenter;
 
    if(StripOrder == LeftToRight) {
        XRotationCenter =  XLeftPointOfStripNumbering;
        YRotationCenter =  YLeftPointOfStripNumbering;
    }
    else {
        if(StripOrder == RightToLeft) {
            XRotationCenter =  XRightPointOfStripNumbering;
            YRotationCenter =  YRightPointOfStripNumbering;
        }
    }
    Double_t StripX = (x - XRotationCenter)*Cos(-AngleRad) + (y - YRotationCenter)*Sin(-AngleRad) + XRotationCenter;//see
    return StripX;
}
 
Double_t BmnVSPLayer::ConvertNormalPointToStripY(Double_t x, Double_t y) {
    Double_t XRotationCenter;
    Double_t YRotationCenter;
 
    if(StripOrder == LeftToRight) {
        XRotationCenter =  XLeftPointOfStripNumbering;
        YRotationCenter =  YLeftPointOfStripNumbering;
    }
    else {
        if(StripOrder == RightToLeft) {
            XRotationCenter =  XRightPointOfStripNumbering;
            YRotationCenter =  YRightPointOfStripNumbering;
        }
    }
    Double_t StripY = -(x - XRotationCenter)*Sin(-AngleRad) + (y - YRotationCenter)*Cos(-AngleRad) + YRotationCenter;//see
    return StripY;
}
 
Double_t BmnVSPLayer::ConvertPointToStripPosition(Double_t x, Double_t y) {
    //This function returns real(double) value,
    //where integer part - number of a strip, fractional part - position on this strip (as ratio from begin)
 
    if(StripOrder == LeftToRight) {
        return (ConvertNormalPointToStripX(x, y)-XLeftPointOfStripNumbering)/Pitch + FirstStripNumber;
    }
    else {
        if(StripOrder == RightToLeft) {
            return (XRightPointOfStripNumbering-ConvertNormalPointToStripX(x, y))/Pitch + FirstStripNumber;
        }
    }
 
    return -1;
}
 
Double_t BmnVSPLayer::CalculateStripEquationB(Double_t strip_pos) {
 
    Double_t b;
 
    if(Abs(AngleDeg) != 90.0) { //case: y=a*x+b
        Double_t x_strip_shift = ((strip_pos-FirstStripNumber)*Pitch)/Cos(Abs(AngleRad));
        Double_t xcoord;
 
        if(StripOrder == LeftToRight) {
            xcoord = XLeftPointOfStripNumbering + x_strip_shift;
            b = YLeftPointOfStripNumbering - Tan(PiOver2()-AngleRad)*xcoord;
        }
        else {
            if(StripOrder == RightToLeft) {
                xcoord = XRightPointOfStripNumbering-x_strip_shift;
                b = YRightPointOfStripNumbering - Tan(PiOver2()-AngleRad)*xcoord;
            }
        }
    }
    else { //case: y=b
        Double_t y_strip_shift = (strip_pos-FirstStripNumber)*Pitch*Sin(AngleRad);
 
        if(StripOrder == LeftToRight) {
            b = YLeftPointOfStripNumbering - y_strip_shift;
        }
        else {
            if(StripOrder == RightToLeft) {
                b = YRightPointOfStripNumbering + y_strip_shift;
            }
        }
    }
 
    return b;
}
 
void BmnVSPLayer::FindClustersAndStripHits() {
 
    ResetStripHits();
 
    Double_t threshold = ClusterFindingThreshold;
    //Double_t threshold = 500.0;
 
    StripCluster cluster;
 
    Bool_t ascent = false;
    Bool_t descent = false;
 
    //Processing strips
    vector<Double_t> AnalyzableStrips = Strips;
 
    //Smooth strip signal ------------------------------------------------------
    //if(Pitch > 0.079) SmoothStripSignal(AnalyzableStrips, 1, 1, 1.0);
    //else SmoothStripSignal(AnalyzableStrips, 2, 1, 1.0);
    //--------------------------------------------------------------------------
 
    for (Int_t is = 0; is < (Int_t)AnalyzableStrips.size(); is++)
    {
        if (AnalyzableStrips.at(is) <= threshold)
        {
            if(descent || ascent) {
                descent = false;
                ascent = false;
                //make strip hit
                MakeStripHit(cluster, AnalyzableStrips, is);
            }
            continue;
        }
 
        if( cluster.GetClusterSize() > 0 ) {
            if( AnalyzableStrips.at(is) >= (cluster.Signals.at(cluster.GetClusterSize()-1)) ) {
                if(descent) {
                    ascent = false;
                    descent = false;
                    //make strip hit
                    MakeStripHit(cluster, AnalyzableStrips, is);
                    //continue;
                }
                ascent = true;
                descent = false;
            }
            else {
                ascent = false;
                descent = true;
            }
        }
        else {
            ascent = true;
            descent = false;
        }
 
        cluster.AddStrip(is, AnalyzableStrips.at(is));
    }
 
    if(cluster.GetClusterSize() != 0) {
        //make strip hit
        Int_t lastnum = AnalyzableStrips.size()-1;
        MakeStripHit(cluster, AnalyzableStrips, lastnum);
    }
}
 
 void BmnVSPLayer::MakeStripHit(StripCluster &cluster, vector<Double_t> &AnalyzableStrips, Int_t &curcnt) {
 
    Double_t mean_strip_position = 0.0;
    Double_t total_cluster_signal = 0.0;
    Double_t cluster_rms = 0.0;
 
    Int_t NStripsInCluster = cluster.GetClusterSize();
 
    //Share the common strip signal of two adjacent clusters in half
    if(true) {
        if(AnalyzableStrips.at(curcnt) >= AnalyzableStrips.at(curcnt-1)) {
            cluster.Signals.at(cluster.Signals.size()-1) *= 0.5;
            AnalyzableStrips.at(curcnt-1) *= 0.5;
        }
    }
 
    //mean position and cluster signal -----------------------------------------
    for(Int_t i = 0; i < NStripsInCluster; ++i) {
        Double_t strip_num = cluster.Strips.at(i) + FirstStripNumber;
        Double_t signal = cluster.Signals.at(i);
        total_cluster_signal += signal;
        mean_strip_position += (strip_num+0.5)*signal;
    }
    mean_strip_position /= total_cluster_signal;
 
    if(mean_strip_position < FirstStripNumber) mean_strip_position = FirstStripNumber;
    if(mean_strip_position >= AnalyzableStrips.size()+FirstStripNumber) mean_strip_position = AnalyzableStrips.size() - 0.001;
    //--------------------------------------------------------------------------
 
    //cluster standard deviation (sigma): RMS ----------------------------------
//    if(NStripsInCluster > 1) {
//        for(Int_t i = 0; i < NStripsInCluster; ++i) {
//            Double_t strip_num = cluster.Strips.at(i) + FirstStripNumber;
//            Double_t signal = cluster.Signals.at(i);
//            Double_t residual = (strip_num+0.5) - mean_strip_position;
//            cluster_rms += residual*residual*signal;
//        }
//        cluster_rms /= total_cluster_signal;
//        cluster_rms = TMath::Sqrt(cluster_rms);
//    }
//    else {
//        cluster_rms = 1.0/TMath::Sqrt(12.0);
//    }
//
 
    // AZ, STS, method2
    Double_t sumW = total_cluster_signal;
    Double_t sumWX = 0.;
    Double_t sumWX2 = 0.;
    if(NStripsInCluster > 1) {
        for(Int_t i = 0; i < NStripsInCluster; ++i) {
           Double_t strip_num = cluster.Strips.at(i) + FirstStripNumber;
           Double_t signal = cluster.Signals.at(i);
           sumWX += strip_num * signal;
           sumWX2 += strip_num * strip_num * signal;
        }
        cluster_rms = (sumWX2 - sumWX * sumWX / sumW) / sumW;
    }
 
    else {
        cluster_rms = 1.0 /TMath::Sqrt(12.0);
    }
 
    //--------------------------------------------------------------------------
 
    StripHits.push_back(mean_strip_position);
    StripHitsTotalSignal.push_back(total_cluster_signal);
    StripHitsErrors.push_back(cluster_rms);
    StripHitsClusterSize.push_back(NStripsInCluster);
 
    cluster.MeanPosition = mean_strip_position;
    cluster.TotalSignal = total_cluster_signal;
    cluster.SetWidth(NStripsInCluster);
    cluster.Error = cluster_rms;
    if (LayerType == LowerStripLayer) {
        cluster.SetType(0);
        cluster.SetUniqueID(fUniqueIdL++);
    } else {
        cluster.SetType(1);
        cluster.SetUniqueID(fUniqueIdU++);
    }
 
    /* Update strip numbers in the local cluster according to
     * the FirstStripNumber shift before we can use it in the outer code
     */
    for(Int_t i = 0; i < NStripsInCluster; ++i) {
        cluster.Strips.at(i) += FirstStripNumber;
    }
 
    StripClusters.push_back(cluster);
 
    //return to a previous strip
    curcnt--;
    if( curcnt < 0 ) curcnt = 0;
 
    cluster.Clear();
 }
 
 void BmnVSPLayer::SmoothStripSignal(vector<Double_t>& AnalyzableStrips, Int_t NIterations, Int_t SmoothWindow, Double_t Weight) {
     //It's the Simple Moving Average (SMA) method
    //AnalyzableStrips - analyzable strip layer (ref)
    //NIterations - number of smooth iterations (usually 1)
    //SmoothWindow - number of strips on the left-right of the current strip (usually 1)
    //Weight - weight of the current strip (usually 1.0 - for simplicity, greater - for weighted value))
 
    SmoothStrips.clear();
    size_t NStrips = AnalyzableStrips.size();
 
    for (Int_t iteration = 0; iteration < NIterations; ++iteration)
    {
        SmoothStrips.clear();
        for (size_t istrip = 0; istrip < NStrips; ++istrip)
        {
            Double_t mean_value = 0.0;
            for (size_t iw = istrip-SmoothWindow; iw <= (size_t)istrip+SmoothWindow; ++iw)
            {
                if (iw >= 0 && iw < NStrips)
                {
                    if (iw == istrip) mean_value += AnalyzableStrips[iw]*Weight;
                    else mean_value += AnalyzableStrips[iw];
                }
            }
            mean_value /= 2.0*SmoothWindow + Weight;
            SmoothStrips.push_back(mean_value);
        }
        AnalyzableStrips = SmoothStrips;
    }
 
    return;
}