RayTracer.cc

Go to the documentation of this file.

#include "RayTracer.h"
#include "Filter.h"
#include "Lens.h"
#include "Mirror.h"
#include "Camera.h"

#include <fdet/Telescope.h>

#include <utl/RandomEngine.h>
#include <utl/Photon.h>

#include <fwk/RunController.h>
#include <evt/Event.h>
#include <evt/Header.h>

#include <TPolyLine3D.h>
#include <TCanvas.h>
#include <TObjArray.h>
#include <TFile.h>
#include <TRandom.h>

#include <string>
#include <iostream>

using namespace std;
using namespace TelescopeSimulatorKG;

int TelescopeSimulatorKG::RayTracer::fgDebugLevel = 0;


RayTracer::RayTracer(const fdet::Telescope& tel,
                     utl::RandomEngine& random,
                     bool doShadow, 
                     bool doShadowSupport, 
                     bool hasMercedes,
                     bool plotPhotonTracks,
                     double drawPhotonsProbabilty)
  : fTel(&tel),
    fRandom(&random),
    fDoShadow(doShadow),
    fDoShadowSupport(doShadowSupport),
    fHasMercedes(hasMercedes),
    fPlotPhotonTracks(plotPhotonTracks),
    fDrawPhotonProbability(drawPhotonsProbabilty) {
    
  fHasCorrectorRing = fTel->HasCorrectorRing();
  
  fFilter = new Filter(random, tel);
  fLens = new Lens(random, tel);
  fMirror = new Mirror(random, tel);
  fCamera = new Camera(random, tel);
  
  if (plotPhotonTracks) 
    fObjectsPhotons = new TObjArray(100);
}


RayTracer::~RayTracer() {

  if (fPlotPhotonTracks) {
    ostringstream fnameBase, fnameRoot, fnameCanvas;
    const string id = fwk::RunController::GetInstance().GetCurrentEvent().GetHeader().GetId();
    fnameBase << "raytrace_" << id
              << "_Eye" << fTel->GetEyeId()
              << "_Tel" << fTel->GetId();
    fnameRoot << fnameBase.str() << ".root";
    fnameCanvas << fnameBase.str() << ".eps";
    TCanvas c("view3d");
    //TObjArray* objectsCamera = fCamera->Draw();
    //TObjArray* objectsLens = fLens->Draw();
    //TObjArray* objectsMirror = fMirror->Draw();
    //TObjArray* objectsFilter = fFilter->Draw();
    for (int iObj=0; iObj < fObjectsPhotons->GetEntriesFast(); ++iObj) {
      TPolyLine3D* photon = dynamic_cast<TPolyLine3D*>((*fObjectsPhotons)[iObj]);
      if (photon) 
        photon->Draw();
    }
    c.Print(fnameCanvas.str().c_str());
    TFile f(fnameRoot.str().c_str(), "RECREATE");
    /*
      objectsFilter->Write("filter");
      objectsLens->Write("lens");
      objectsMirror->Write("mirror");
      objectsCamera->Write("camera");
      fObjectsPhotons->Write("photons");
    */
    c.Write();
    f.Close();
  }
  
  delete fFilter;
  delete fLens;
  delete fMirror;
  delete fCamera;
}


RTResult RayTracer::Trace(const utl::Photon& photonIn,
                          utl::Photon& photonOut,
                          int& nreflections, int& col, int& row) {
  
  nreflections = 0;
  
  bool plotTrack = false;
  int trackColor = kBlue;
  if (fPlotPhotonTracks) {
    plotTrack = (gRandom->Rndm() < fDrawPhotonProbability);
    const utl::CoordinateSystemPtr& telCS = fTel->GetTelescopeCoordinateSystem();
    if (photonIn.GetPosition().GetR(telCS)<0.85*utl::meter) {
      trackColor = kRed;
    }
  }
  

    
  utl::Photon photonFilter;
  if (fFilter->Trace(photonIn, photonFilter) != eOK) 
    return eAbsorbedByFilter;  
  if (plotTrack) 
    fObjectsPhotons->AddLast(DrawTrack(photonIn.GetPosition(), photonFilter.GetPosition(), trackColor));
  
  
  utl::Photon photonDiaphragm = photonFilter;
  if (fHasCorrectorRing) {
    
    const RTResult lensStatus = fLens->Trace(photonFilter, photonDiaphragm);
    if (lensStatus != eOK)
      return lensStatus;
    
  }
  if (plotTrack) 
    fObjectsPhotons->AddLast(DrawTrack(photonFilter.GetPosition(), photonDiaphragm.GetPosition(), trackColor));
  
  if (fDoShadow) {
    if (fCamera->TraceShadow(photonDiaphragm, fDoShadowSupport) != eOK) 
      return eShadowed;    
  }

  
  utl::Photon photonMirror;
  const RTResult mirStatus = fMirror->Trace (photonDiaphragm, photonMirror);
  if (mirStatus != eOK)
    return eAbsorbedByMirror; 
  
  if (plotTrack) 
    fObjectsPhotons->AddLast(DrawTrack(photonDiaphragm.GetPosition(), photonMirror.GetPosition(), trackColor));
  
  
  
  double cosTheta = 0;
  RTResult status = fCamera->Trace(photonMirror, photonOut, nreflections, col, row, cosTheta, fHasMercedes);
  //if (fHasMercedes) result = fCamera->Trace (photonMirror, photonOut, col, row, cosTheta, +2);  // WITH MERCEDES
  //else              result = fCamera->Trace (photonMirror, photonOut, col, row, cosTheta, -2);  // WITHOUT MERCEDES
  cosTheta *= -1;
  
  if (/*status == eOK &&*/ plotTrack) {
    fObjectsPhotons->AddLast(DrawTrack(photonMirror.GetPosition(), photonOut.GetPosition(), trackColor));
  }
  
  
  if (status != eOK) {
    col = -1;  // camera not hit
    row = -1;
    return status;
  }
  
  return eOK;

}// end of TelescopeSimulator::RayTracing



TPolyLine3D* RayTracer::DrawTrack(const utl::Point& p1, const utl::Point& p2, int color) const {
  // for plottings
  const utl::CoordinateSystemPtr& telCS = fTel->GetTelescopeCoordinateSystem();
  TPolyLine3D* track = new TPolyLine3D(2);
  track->SetPoint(0, p1.GetX(telCS), p1.GetY(telCS), p1.GetZ(telCS));
  track->SetPoint(1, p2.GetX(telCS), p2.GetY(telCS), p2.GetZ(telCS));
  track->SetLineColor(color);
  return track;
}