BmnZdcBScanner.cxx

Go to the documentation of this file.

/*
 * File:   BmnZdcBScanner.cxx
 * Author: pnaleks <pnaleks@gmail.com>
 *
 * Created on 25 октября 2019 г., 12:15
 */
 
#include "BmnZdcBScanner.h"
 
#include <BmnEventHeader.h>
#include <FairMCEventHeader.h>
 
void BmnZdcBScanner::SetEventData(TClonesArray* pArrayOfBmnZDCDigit, Double_t scale)
{
    Int_t N = pArrayOfBmnZDCDigit->GetEntries();
    printf("SetEventData from %d entries\n", N);
    fEventData.Reset();
    for (Int_t i = 0; i < N; i++) {
        BmnZDCDigit* p = (BmnZDCDigit*)pArrayOfBmnZDCDigit->At(i);
        if (p == 0)
            continue;
        fEventData.Add(p, scale);
    }
}
 
TH1D* BmnZdcBScanner::Scan(char mode)
{
    printf("Starting scan\n");
    TString name = TString::Format("BSpectrum_%c", mode);
    TString title = TString::Format("b-spectrum from %c", mode);
    TH1D* pH = new TH1D(name.Data(), title.Data(), 100, 0, 20);
 
    TClonesArray* pArrayOfBmnZDCDigit = new TClonesArray("BmnZDCDigit");
    fInpChain.SetBranchAddress("ZDC", &pArrayOfBmnZDCDigit);
 
    FairMCEventHeader* pHeader = new FairMCEventHeader();
    fInpChain.SetBranchAddress("MCEventHeader.", &pHeader);
 
    UInt_t entries = fInpChain.GetEntries();
    if (fMaxEntries && entries > fMaxEntries)
        entries = fMaxEntries;
 
    printf("Started for %u entries\n", entries);
 
    if (fIndex)
        delete fIndex;
 
    fIndexSize = 0;
    fIndex = new Item[entries];
    if (!fIndex)
        throw;
 
    UInt_t percent = entries / 100;
    for (UInt_t i = 0; i < entries; i++) {
        fInpChain.GetEntry(i);
 
        OnEvent(pArrayOfBmnZDCDigit, mode, pHeader->GetB());
 
        if (fShowProgress && percent > 0 && i % percent == 0)
            DrawBar(i, entries);
    }
 
    std::sort(fIndex, fIndex + fIndexSize, BmnZdcBScanner::compareItem);
 
    Double_t scanValue;
    switch (mode) {
        case 'A':
            scanValue = fEventData.GetA();
            break;
        case 'E':
            scanValue = fEventData.GetE();
            break;
        case 'H':
            scanValue = fEventData.GetHits();
            break;
        case 'M':
            scanValue = fEventData.GetM();
            break;
        default:
            printf("Unexpected mode '%c'\n", mode);
            throw;
    }
 
    OnScan(fScanWidth, scanValue, pH);
 
    return pH;
}
 
void BmnZdcBScanner::OnEvent(TClonesArray* pArrayOfBmnZDCDigit, char mode, Double_t b)
{
    Int_t N = pArrayOfBmnZDCDigit->GetEntries();
 
    ZdcMoment MoI;
 
    for (Int_t i = 0; i < N; i++) {
        BmnZDCDigit* p = (BmnZDCDigit*)pArrayOfBmnZDCDigit->At(i);
        if (p == 0)
            continue;
        MoI.Add(p, fSimScale);
    }
 
    if (MoI.GetE() == 0.)
        return;
 
    Item* p = fIndex + fIndexSize++;
    switch (mode) {
        case 'A':
            p->index = MoI.GetA();
            break;
        case 'E':
            p->index = MoI.GetE();
            break;
        case 'H':
            p->index = MoI.GetHits();
            break;
        case 'M':
            p->index = MoI.GetM();
            break;
        default:
            printf("Unexpected mode '%c'\n", mode);
            throw;
    }
 
    p->b = b;
}
 
void BmnZdcBScanner::OnScan(Int_t n, Double_t scanValue, TH1D* pBH)
{
    if (n > (Int_t)fIndexSize)
        n = fIndexSize;
    Int_t cnt = 0;
 
    UInt_t iFwd = 0;
    UInt_t iRew = 0;
    Double_t dPos = fIndex[iFwd].index - scanValue;
    Double_t dNeg = 0;
 
    // Double_t bS = 0;
    // Double_t bSS = 0;
 
    while (dPos <= 0) {
        iFwd++;
        if (iFwd >= fIndexSize)
            return;
        dPos = fIndex[iFwd].index - scanValue;
    }
 
    if (iFwd > 0) {
        iRew = iFwd - 1;
        dNeg = scanValue - fIndex[iRew].index;
    }
 
    while (cnt < n) {
        Int_t i = -1;
        if (dNeg > 0 && (dNeg < dPos || iFwd >= fIndexSize - 1)) {
            if (iRew > 0) {
                iRew--;
                i = iRew;
                dNeg = scanValue - fIndex[iRew].index;
            }
        } else {
            if (iFwd < fIndexSize - 1) {
                iFwd++;
                i = iFwd;
                dPos = fIndex[iFwd].index - scanValue;
            }
        }
        if (i < 0) {
            return;
        } else {
            cnt++;
            Double_t b = fIndex[i].b;
            if (pBH)
                pBH->Fill(b);
        }
    }
}