TRestAxionOptics.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 _TRestAxionOptics
#define _TRestAxionOptics
 
#include <TRestAxionOpticsMirror.h>
#include <TRestCombinedMask.h>
#include <TRestMetadata.h>
 
#include <iostream>
 
#include "TRandom3.h"
 
class TRestAxionOptics : public TRestMetadata {
   protected:
    std::string fOpticsFile = "";
 
    Double_t fMirrorLength = 0;  //<
 
    std::vector<std::vector<Double_t>> fOpticsData;  //<
 
    TRestAxionOpticsMirror* fMirrorProperties = nullptr;  //<
 
    TRestCombinedMask* fEntranceMask = nullptr;  
 
    TRestCombinedMask* fMiddleMask = nullptr;  
 
    TRestCombinedMask* fExitMask = nullptr;  
 
    TVector3 fOriginPosition;  
 
    TVector3 fEntrancePosition;  
 
    TVector3 fFirstInteractionPosition;  
 
    TVector3 fMiddlePosition;  
 
    TVector3 fSecondInteractionPosition;  
 
    TVector3 fExitPosition;  
 
    TVector3 fEntranceDirection;  
 
    TVector3 fMiddleDirection;  
 
    TVector3 fExitDirection;  
 
    Double_t fFocal = -1;  
 
    Int_t fCurrentMirror = -1;  
 
    Bool_t fFirstInteraction = false;  
 
    Bool_t fSecondInteraction = false;  
 
    TRandom3* fRandom = nullptr;  
 
    TRestAxionOptics();
    TRestAxionOptics(const char* cfgFileName, std::string name = "");
 
   private:
    void ResetPositions();
 
    Double_t GetPhotonReflectivity(Double_t energy);
 
   protected:
    TPad* fPad = nullptr;
 
    Int_t TransportToEntrance(const TVector3& pos, const TVector3& dir);
    Int_t TransportToMiddle(const TVector3& pos, const TVector3& dir);
    Int_t TransportToExit(const TVector3& pos, const TVector3& dir);
 
    Int_t GetMirror() { return fCurrentMirror; }
 
    virtual void SetMirror() = 0;
 
   public:
    virtual void Initialize();
 
    virtual std::pair<Double_t, Double_t> GetRadialLimits() = 0;
 
    virtual Double_t GetEntrancePositionZ() = 0;
 
    virtual Double_t GetExitPositionZ() = 0;
 
    virtual Int_t FirstMirrorReflection(const TVector3& pos, const TVector3& dir) = 0;
 
    virtual Int_t SecondMirrorReflection(const TVector3& pos, const TVector3& dir) = 0;
 
    virtual TPad* DrawMirrors() = 0;
 
    Double_t GetEntranceAngle() { return TMath::ACos(fEntranceDirection.Dot(TVector3(0, 0, 1))); }
 
    virtual Double_t FindFocal(Double_t from, Double_t to, Double_t energy, Double_t precision = 1,
                               Bool_t recalculate = false, Int_t particles = 5000);
 
    Double_t CalculateSpotSize(Double_t energy, Double_t z, Int_t particles = 15000);
 
    TPad* CreatePad(Int_t nx = 1, Int_t ny = 1);
 
    TPad* DrawParticleTracks(Double_t deviation = 0, Int_t particles = 10);
 
    TPad* DrawScatterMaps(Double_t z, Double_t energy = 0, Double_t deviation = 0, Int_t particles = 1000,
                          Double_t focalHint = 7500);
 
    TPad* DrawDensityMaps(Double_t z, Double_t energy = 0, Double_t deviation = 0, Int_t particles = 1000,
                          Double_t focalHint = 7500);
 
    Double_t PropagatePhoton(const TVector3& pos, const TVector3& dir, Double_t energy);
 
    Double_t PropagateMonteCarloPhoton(Double_t energy, Double_t deviation);
 
    TVector3 GetEntrancePosition() { return fEntrancePosition; }
 
    TVector3 GetMiddlePosition() { return fMiddlePosition; }
 
    TVector3 GetExitPosition() { return fExitPosition; }
 
    TVector3 GetEntranceDirection() { return fEntranceDirection; }
 
    TVector3 GetMiddleDirection() { return fMiddleDirection; }
 
    TVector3 GetExitDirection() { return fExitDirection; }
 
    TVector3 GetLastGoodPosition();
    TVector3 GetLastGoodDirection();
 
    Bool_t IsFirstMirrorReflection() { return fFirstInteraction; }
 
    Bool_t IsSecondMirrorReflection() { return fSecondInteraction; }
 
    Int_t GetNumberOfReflections();
 
    TRestCombinedMask* const& GetEntranceMask() const { return fEntranceMask; }
 
    TRestCombinedMask* const& GetMiddleMask() const { return fMiddleMask; }
 
    TRestCombinedMask* const& GetExitMask() const { return fExitMask; }
 
    TRestAxionOpticsMirror* const& GetMirrorProperties() const { return fMirrorProperties; }
 
    void PrintMetadata();
 
    void PrintMirror();
    void PrintMasks();
 
    void PrintEntranceMask();
    void PrintMiddleMask();
    void PrintExitMask();
 
    void PrintPhotonTrackingSummary();
 
    void InitFromConfigFile();
 
    ~TRestAxionOptics();
 
    ClassDef(TRestAxionOptics, 1);
};
#endif