TRestMesh.h

/*************************************************************************
 * 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.                  *
 *************************************************************************/
 
#ifndef RestCore_TRestMesh
#define RestCore_TRestMesh
 
#include <TObject.h>
#include <TVector3.h>
 
#include <iostream>
 
#include "TRestHits.h"
 
constexpr int NODE_NOT_SET = -1;
constexpr int GROUP_NOT_FOUND = -1;
constexpr int NODE_NOT_FOUND = -1;
 
class TRestMesh : public TObject {
   protected:
    TVector3 fNetOrigin = TVector3(0, 0, 0);
 
    Double_t fNetSizeX = 0;
    Double_t fNetSizeY = 0;
    Double_t fNetSizeZ = 0;
 
    Int_t fNodesX = 0;
    Int_t fNodesY = 0;
    Int_t fNodesZ = 0;
 
    Int_t fNumberOfNodes = 0;
    Int_t fNumberOfGroups = 0;
 
    std::vector<Int_t> fNodeGroupID;
    std::vector<Int_t> fNodeX;
    std::vector<Int_t> fNodeY;
    std::vector<Int_t> fNodeZ;
 
    std::vector<Double_t> fEnergy;
 
    Bool_t fIsCylindrical = false;
    Bool_t fIsSpherical = false;
 
   public:
    Double_t GetX(Int_t nX);
    Double_t GetY(Int_t nY);
    Double_t GetZ(Int_t nZ);
 
    inline Int_t GetNumberOfNodes() const { return fNumberOfNodes; }
    inline Int_t GetNumberOfGroups() const { return fNumberOfGroups; }
 
    TVector3 GetPosition(Int_t nX, Int_t nY, Int_t nZ);
 
    Int_t GetNodeX(Double_t x, Bool_t relative = false);
    Int_t GetNodeY(Double_t y, Bool_t relative = false);
    Int_t GetNodeZ(Double_t z, Bool_t relative = false);
 
    Int_t GetNodeX(TVector3 v, Bool_t relative = false);
    Int_t GetNodeY(TVector3 v, Bool_t relative = false);
    Int_t GetNodeZ(TVector3 v, Bool_t relative = false);
 
    Bool_t IsCylindrical() { return fIsCylindrical; }
    Bool_t IsSpherical() { return fIsSpherical; }
 
    TVector3 GetNodeByIndex(Int_t index) {
        TVector3 node(fNodeX[index], fNodeY[index], fNodeZ[index]);
        return node;
    }
 
    Double_t GetEnergyAtNode(Int_t nx, Int_t ny, Int_t nz) { return fEnergy[GetNodeIndex(nx, ny, nz)]; }
 
    void SetNodesFromHits(TRestHits* hits);
    void SetNodesFromSphericalHits(TRestHits* hits);
    void Regrouping();
 
    Int_t GetNodeIndex(Int_t nx, Int_t ny, Int_t nz);
 
    Int_t GetGroupId(Double_t x, Double_t y, Double_t z);
    Int_t GetGroupId(Int_t index);
 
    Double_t GetGroupEnergy(Int_t index);
    TVector3 GetGroupPosition(Int_t index);
 
    Int_t FindNeighbourGroup(Int_t nx, Int_t ny, Int_t nz);
    Int_t FindForeignNeighbour(Int_t nx, Int_t ny, Int_t nz);
 
    void SetOrigin(Double_t oX, Double_t oY, Double_t oZ);
    void SetOrigin(TVector3 pos);
 
    void SetSize(Double_t sX, Double_t sY, Double_t sZ);
 
    void SetNodes(Int_t nX, Int_t nY, Int_t nZ);
 
    void SetCylindrical(Bool_t v) { fIsCylindrical = v; }
 
    void SetSpherical(Bool_t v) {
        if (v && (fNetSizeX != fNetSizeY || fNetSizeY != fNetSizeZ))
            std::cout << "Warning!! The net size should be the same in X, Y and Z for spherical net!"
                      << std::endl;
 
        fIsSpherical = v;
    }
 
    inline Int_t GetNodesX() const { return fNodesX; }
    inline Int_t GetNodesY() const { return fNodesY; }
    inline Int_t GetNodesZ() const { return fNodesZ; }
 
    inline Double_t GetNetSizeX() const { return fNetSizeX; }
    inline Double_t GetNetSizeY() const { return fNetSizeY; }
    inline Double_t GetNetSizeZ() const { return fNetSizeZ; }
 
    inline TVector3 GetOrigin() const { return fNetOrigin; }
    inline TVector3 GetNetSize() const { return {fNetSizeX, fNetSizeY, fNetSizeZ}; }
    TVector3 GetNetCenter();
    TVector3 GetVertex(Int_t id) const;
 
    inline TVector3 GetBottomVertex() const { return GetVertex(0); }
    inline TVector3 GetTopVertex() const { return GetVertex(1); }
 
    void AddNode(Double_t x, Double_t y, Double_t z, Double_t en = 0);
    void AddSphericalNode(Double_t x, Double_t y, Double_t z, Double_t en = 0);
 
    void RemoveNodes();
 
    Bool_t IsInside(TVector3 pos);
    Bool_t IsInsideBoundingBox(TVector3 pos);
 
    std::vector<TVector3> GetTrackBoundaries(TVector3 pos, TVector3 dir, Bool_t particle = true);
    std::vector<TVector3> GetTrackBoundariesCylinder(TVector3 pos, TVector3 dir, Bool_t particle = true);
 
    void Print();
 
    // Constructor
    TRestMesh();
 
    TRestMesh(Double_t size, Int_t nodes);
    TRestMesh(TVector3 size, TVector3 position, Int_t nx, Int_t ny, Int_t nz);
    // Destructor
    ~TRestMesh();
 
    ClassDef(TRestMesh, 2);
};
#endif