KVElasticScatter.h

/*
$Id: KVElasticScatter.h,v 1.6 2007/04/04 10:39:17 ebonnet Exp $
$Revision: 1.6 $
$Date: 2007/04/04 10:39:17 $
*/
 
 
#ifndef __KVELASTICSCATTER_H
#define __KVELASTICSCATTER_H
 
#include "TVector3.h"
#include "KVNameValueList.h"
#include "KVNucleus.h"
#include "KV2Body.h"
#include <optional>
 
class TH1F;
class TList;
class KVGroup;
class KVDetector;
class KVTarget;
class TObjArray;
 
class KVElasticScatter {
 
   TH1F* fDepth = nullptr;                //depth of scattering point in target
   TH1F* fTheta = nullptr;                //angle of scattered particle
   Int_t  fBinE = 100;                //Number of bins of the Energy histogram
   KV2Body* fKinematics = nullptr;        //kinematics calculation
   KVDetector* fDetector = nullptr;       //detector where particle will be detected
    TList fAlignedDetectors;
    Int_t fNDets;
   KVTarget* fTarget = nullptr;           //target for current run
   Bool_t fMultiLayer = false;          //kTRUE for multilayer target
   Bool_t fGetTargFromLay = false;      //kTRUE if target nucleus can change from layer to layer
   TVector3 fBeamDirection{0, 0, 1};   //beam direction vector
   Int_t fIntLayer = 0;                 //index of interaction layer in multilayer target
    TObjArray fHistos;
    KVNameValueList fDetInd;
   Double_t fExx = 0.0; // excitation of target
    std::optional<KVNucleus> fOutgoingPL;
    std::optional<KVNucleus> fTargetNuc;
   void SetRun(Int_t run);
   KV2Body::nucleus_of_interest fNucleusOfInterest = KV2Body::nucleus_of_interest::projectile_like;
   KV2Body::kinematic_solution fKineSol = KV2Body::kinematic_solution::high_E_branch;
 
protected:
   Double_t fNtirages;
    Double_t fAtomicDensity;
   virtual bool initial_checks_and_reset();
   virtual void reset_before_new_scattering() {}
   virtual std::pair<double, double> get_random_angles_for_scattering(const KV2Body& scattering_kinematics);
   virtual void detect_particle_fill_histograms(KVNucleus* ejectile, double theta, double phi, double xsec);
   virtual void end_of_run() {}
 
public:
   KVElasticScatter(Int_t run);
   virtual ~ KVElasticScatter();
 
   void SetBeamDirection(const TVector3& beam_dir)
   {
      fBeamDirection = beam_dir;
   }
   void SetTargetScatteringLayer(const Char_t* name);
   void SetNucleusOfInterest(KV2Body::nucleus_of_interest noi)
   {
      fNucleusOfInterest = noi;
   }
   void SetKinematicSolution(KV2Body::kinematic_solution ik)
   {
      fKineSol = ik;
   }
 
   void SetEbinning(Int_t nbins);
   void SetDetector(const Char_t* det);
   void CalculateScattering(Int_t N);
   void SetExcitation(Double_t ex)
   {
      fExx = ex;
   }
   void SetOutGoingProjectileLike(const KVNucleus& opl)
   {
      fOutgoingPL = opl;
      fKinematics->SetOutgoing(opl);
      fKinematics->CalculateKinematics();
   }
   void GetTargetNucleusFromTargetLayer(Bool_t yes = kTRUE)
   {
      fGetTargFromLay = yes;
   }
   void SetTargetNucleusForScattering(const KVNucleus& tn)
   {
      fTargetNuc = tn;
      fKinematics->SetTarget(tn);
      fKinematics->CalculateKinematics();
   }
 
   TH1F* GetDepth()
   {
      return fDepth;
   }
   TH1F* GetEnergy()
   {
      return GetEnergy(fNDets - 1);
   }
   TH1F* GetTheta()
   {
      return fTheta;
   }
   TH1F* GetEnergy(const Char_t* label);
   TH1F* GetEnergy(Int_t index);
   Int_t GetNDets() const
   {
      return fNDets;
   }
   Int_t GetEbinning(void)
   {
      return fBinE;
   }
   auto GetKinematics()
   {
      return fKinematics;
   }
 
   void Print() const;
 
   ClassDef(KVElasticScatter, 0)        //Calculate elastic scattering spectra in multidetector arrays
};
 
#endif