TRestPatternMask.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see https://gifna.unizar.es/trex                 *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see https://www.gnu.org/licenses/.                            *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
 
#include "TRestPatternMask.h"
 
#include "TAxis.h"
#include "TColor.h"
#include "TGraph.h"
#include "TH1F.h"
#include "TRandom3.h"
 
ClassImp(TRestPatternMask);
 
TRestPatternMask::TRestPatternMask() : TRestMetadata() { Initialize(); }
 
TRestPatternMask::TRestPatternMask(const char* cfgFileName, std::string name) : TRestMetadata(cfgFileName) {
    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Info) PrintMetadata();
}
 
TRestPatternMask::~TRestPatternMask() {}
 
Int_t TRestPatternMask::ApplyCommonMaskTransformation(Double_t& x, Double_t& y) {
    if (fMaskRadius > 0 && x * x + y * y > fMaskRadius * fMaskRadius) return 0;
 
    TVector2 pos(x, y);
 
    pos = pos.Rotate(-fRotationAngle);
    pos -= fOffset;
 
    x = pos.X();
    y = pos.Y();
 
    return 1;
}
 
bool TRestPatternMask::HitsPattern(Double_t x, Double_t y) {
    if (GetRegion(x, y) > 0) return false;
    return true;
}
 
void TRestPatternMask::PrintMetadata() {
    TRestMetadata::PrintMetadata();
 
    PrintCommonPatternMembers();
    RESTMetadata << "----" << RESTendl;
}
 
void TRestPatternMask::PrintCommonPatternMembers() {
    RESTMetadata << " - Pattern type : " << fPatternType << RESTendl;
    RESTMetadata << " - Mask radius : " << fMaskRadius << " mm" << RESTendl;
    RESTMetadata << " - Max regions : " << fMaxRegions << RESTendl;
    RESTMetadata << " - Offset : (" << fOffset.X() << ", " << fOffset.Y() << ") mm" << RESTendl;
    RESTMetadata << " - Rotation angle : " << fRotationAngle * 180. / TMath::Pi() << " degrees" << RESTendl;
}
 
TCanvas* TRestPatternMask::DrawMonteCarlo(Int_t nSamples) {
    if (fCanvas != NULL) {
        delete fCanvas;
        fCanvas = NULL;
    }
    fCanvas = new TCanvas("canv", "This is the canvas title", 1200, 1200);
    fCanvas->Draw();
 
    TPad* pad1 = new TPad("pad1", "This is pad1", 0.01, 0.02, 0.99, 0.97);
    pad1->Draw();
 
    fCanvas->SetRightMargin(0.09);
    fCanvas->SetLeftMargin(0.15);
    fCanvas->SetBottomMargin(0.15);
 
    std::map<int, std::vector<TVector2> > points;
 
    TRandom3* rnd = new TRandom3(0);
 
    for (int n = 0; n < nSamples; n++) {
        Double_t xO = 2.5 * (rnd->Rndm() - 0.5) * fMaskRadius;
        Double_t yO = 2.5 * (rnd->Rndm() - 0.5) * fMaskRadius;
        Double_t x = xO;
        Double_t y = yO;
 
        Int_t id = GetRegion(x, y);
 
        if (points.count(id) == 0) {
            std::vector<TVector2> a;
            a.push_back(TVector2(xO, yO));
            points[id] = a;
        } else {
            points[id].push_back(TVector2(xO, yO));
        }
    }
 
    std::vector<TGraph*> gridGraphs;
    Int_t nGraphs = 0;
    for (const auto& x : points) {
        std::string grname = "gr" + IntegerToString(nGraphs);
        TGraph* gr = new TGraph();
        gr->SetName(grname.c_str());
 
        for (unsigned int n = 0; n < x.second.size(); n++) {
            gr->SetPoint(gr->GetN(), x.second[n].X(), x.second[n].Y());
        }
 
        if (nGraphs == 0) {
            gr->SetLineColor(kBlack);
            gr->SetMarkerColor(kBlack);
            gr->SetMarkerSize(0.6);
            gr->SetLineWidth(2);
        } else {
            gr->SetMarkerColor((nGraphs * 3) % 29 + 20);
            gr->SetLineColor((nGraphs * 3) % 29 + 20);
            gr->SetMarkerSize(0.6);
            gr->SetLineWidth(2);
        }
 
        gr->SetMarkerStyle(20);
        gridGraphs.push_back(gr);
        nGraphs++;
    }
 
    gridGraphs[0]->GetXaxis()->SetLimits(-1.25 * fMaskRadius, 1.25 * fMaskRadius);
    gridGraphs[0]->GetHistogram()->SetMaximum(1.25 * fMaskRadius);
    gridGraphs[0]->GetHistogram()->SetMinimum(-1.25 * fMaskRadius);
 
    gridGraphs[0]->GetXaxis()->SetTitle("X [mm]");
    gridGraphs[0]->GetXaxis()->SetTitleSize(0.04);
    gridGraphs[0]->GetXaxis()->SetLabelSize(0.04);
    gridGraphs[0]->GetYaxis()->SetTitle("Y[mm]");
    gridGraphs[0]->GetYaxis()->SetTitleOffset(1.5);
    gridGraphs[0]->GetYaxis()->SetTitleSize(0.04);
    gridGraphs[0]->GetYaxis()->SetLabelSize(0.04);
    pad1->SetLogy();
    gridGraphs[0]->Draw("AP");
    for (int n = 1; n < nGraphs; n++) gridGraphs[n]->Draw("P");
 
    return fCanvas;
}