TRestTrackLineAnalysisProcess.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://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 http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
 
#include "TRestTrackLineAnalysisProcess.h"
 
#include "TRestTrackReductionProcess.h"
using namespace std;
 
ClassImp(TRestTrackLineAnalysisProcess);
 
TRestTrackLineAnalysisProcess::TRestTrackLineAnalysisProcess() { Initialize(); }
 
TRestTrackLineAnalysisProcess::~TRestTrackLineAnalysisProcess() { delete fOutTrackEvent; }
 
void TRestTrackLineAnalysisProcess::Initialize() {
    SetSectionName(this->ClassName());
    SetLibraryVersion(LIBRARY_VERSION);
 
    fTrackEvent = nullptr;
    fOutTrackEvent = new TRestTrackEvent();
}
 
void TRestTrackLineAnalysisProcess::InitProcess() {}
 
TRestEvent* TRestTrackLineAnalysisProcess::ProcessEvent(TRestEvent* inputEvent) {
    fTrackEvent = (TRestTrackEvent*)inputEvent;
 
    // Initialize outputTrackEvent
    for (int t = 0; t < fTrackEvent->GetNumberOfTracks(); t++)
        fOutTrackEvent->AddTrack(fTrackEvent->GetTrack(t));
 
    TRestTrack* tckX = fTrackEvent->GetMaxEnergyTrackInX();
    TRestTrack* tckY = fTrackEvent->GetMaxEnergyTrackInY();
 
    TVector3 orig = TVector3(0, 0, 0), end = TVector3(0, 0, 0);
    Double_t length = -1;
    Double_t angle = -10;
    bool downwards = true;
    Double_t trackEnergyX = 0, trackEnergyY = 0;
    Double_t trackBalanceX = 0, trackBalanceY = 0, trackBalance = 0, relZ = 0;
 
    if (tckX && tckY) {
        // Retreive origin and end of the track for the XZ projection
        if (fLineAnaMethod == "3D") {
            fTrackEvent->GetMaxTrackBoundaries3D(orig, end);
        } else {
            if (fLineAnaMethod != "default") {
                RESTWarning
                    << "Line analysis method " << fLineAnaMethod
                    << " is not implemented, supported methods are: default and 3D. Falling back to default."
                    << RESTendl;
            }
            fTrackEvent->GetMaxTrackBoundaries(orig, end);
        }
 
        RESTDebug << "Origin: " << orig.X() << " y: " << orig.Y() << " z: " << orig.Z() << RESTendl;
        RESTDebug << "End : " << end.X() << " y: " << end.Y() << " z: " << end.Z() << RESTendl;
 
        // Compute some observables
        double dX = (orig.X() - end.X());
        double dY = (orig.Y() - end.Y());
        double dZ = (orig.Z() - end.Z());
        length = TMath::Sqrt(dX * dX + dY * dY + dZ * dZ);
        angle = TMath::ACos(dZ / length);
        downwards = dZ > 0;
 
        RESTDebug << "Track length " << length << " angle: " << angle << RESTendl;
 
        trackEnergyX = tckX->GetEnergy();
        trackEnergyY = tckY->GetEnergy();
 
        if (trackEnergyX > 0) trackBalanceX = trackEnergyX / fTrackEvent->GetEnergy("X");
        if (trackEnergyY > 0) trackBalanceY = trackEnergyY / fTrackEvent->GetEnergy("Y");
        if (trackEnergyX > 0 && trackEnergyY > 0)
            trackBalance =
                (trackEnergyX + trackEnergyY) / (fTrackEvent->GetEnergy("X") + fTrackEvent->GetEnergy("Y"));
        relZ = fTrackEvent->GetMaxTrackRelativeZ();
    }
 
    Double_t trackEnergy = trackEnergyX + trackEnergyY;
 
    // A new value for each observable is added
    SetObservableValue("trackBalanceX", trackBalanceX);
    SetObservableValue("trackBalanceY", trackBalanceY);
    SetObservableValue("trackBalance", trackBalance);
    SetObservableValue("originX", orig.X());
    SetObservableValue("originY", orig.Y());
    SetObservableValue("originZ", orig.Z());
    SetObservableValue("endX", end.X());
    SetObservableValue("endY", end.Y());
    SetObservableValue("endZ", end.Z());
    SetObservableValue("length", length);
    SetObservableValue("angle", angle);
    SetObservableValue("downwards", downwards);
    SetObservableValue("totalEnergy", trackEnergy);
    SetObservableValue("relativeZ", relZ);
 
    if (!tckX || !tckY) return nullptr;
 
    // Save most energetic XZ track
    tckX->SetParentID(tckX->GetTrackID());
    tckX->SetTrackID(fOutTrackEvent->GetNumberOfTracks() + 1);
    fOutTrackEvent->AddTrack(tckX);
 
    // Save most energetic YZ track
    tckY->SetParentID(tckY->GetTrackID());
    tckY->SetTrackID(fOutTrackEvent->GetNumberOfTracks() + 1);
    fOutTrackEvent->AddTrack(tckY);
 
    fOutTrackEvent->SetLevels();
    return fOutTrackEvent;
}
 
void TRestTrackLineAnalysisProcess::EndProcess() {}