PndSttIsochroneDraw.cxx

Go to the documentation of this file.

// -------------------------------------------------------------------------
// -----                        PndSttIsochroneDraw source file                  -----
// -----                  Created 10/12/07  by M. Al-Turany            -----
// -------------------------------------------------------------------------

#include "PndSttIsochroneDraw.h"
#include "TEveTrack.h"
#include <iostream>
#include "TEveTrackPropagator.h"
#include "TGeoTrack.h"
#include "TClonesArray.h"
#include "TObjArray.h"
#include "TEveManager.h"
#include "FairEventManager.h"
#include "PndTrack.h"
#include "TLorentzVector.h"
#include "TParticle.h"
#include "TEveBoxSet.h"
#include "TEveGeoShape.h"
#include "TGeoMatrix.h"
#include "TGeoTube.h"
#include "TGeoMatrix.h"
#include "PndSttMapCreator.h"
#include "PndSttHit.h"
#include "PndSttTube.h"
#include "PndSttSingleStraw.h"
#include "PndSttPoint.h"
#include "PndSttTubeMap.h"
#include "FairRuntimeDb.h"
#include "FairEventHeader.h"
#include <string>
#include <sstream>
using std::cout;
using std::endl;

// -----   Default constructor   -------------------------------------------
PndSttIsochroneDraw::PndSttIsochroneDraw(Bool_t ) // propagate //[R.K.03/2017] unused variable(s)
   : fTimeWindowPlus(0.), fTimeWindowMinus(0.), fStartTime(-1), fUseEventTime(kTRUE), fUseIsochroneTime(kFALSE),
         fSttHitArray(0), fSttTubeArray(0), fSttParameters(0), fEventManager(0), fEveTrList(0), fListOfIsochrones(0), fListOfTiltedIsochrones(0), fListOfParallelIsochrones(0),
         fStartFunctor(0), fStopFunctor(0), fEventHeaderBranch(0)
{
}
// -------------------------------------------------------------------------


// -----   Standard constructor   ------------------------------------------
PndSttIsochroneDraw::PndSttIsochroneDraw(const char* name, Bool_t , Int_t iVerbose) // propagate //[R.K.03/2017] unused variable(s)
  : FairTask(name, iVerbose), fTimeWindowPlus(0.), fTimeWindowMinus(0.), fStartTime(-1), fUseEventTime(kTRUE), fUseIsochroneTime(kFALSE),
         fSttHitArray(0), fSttTubeArray(0), fSttParameters(0), fEventManager(0), fEveTrList(0), fListOfIsochrones(0), fListOfTiltedIsochrones(0), fListOfParallelIsochrones(0),
         fStartFunctor(0), fStopFunctor(0), fEventHeaderBranch(0)
{
         // fPro = new FairGeanePro();

}


// -------------------------------------------------------------------------
InitStatus PndSttIsochroneDraw::Init()
{
   if (fVerbose > 1)
                cout << "PndSttIsochroneDraw::Init()" << endl;
   if (fSttHitArray == 0){
                FairRootManager* fManager = FairRootManager::Instance();
                fSttHitArray = (TClonesArray *) fManager->GetObject(GetName());
                if (fSttHitArray == 0) {
                        cout << "PndSttIsochroneDraw::Init()  branch " << GetName()
                                        << " Not found! Task will be deactivated " << endl;
                        SetActive(kFALSE);
                }

                fEventManager = FairEventManager::Instance();
                if (fVerbose > 2)
                        cout << "PndSttIsochroneDraw::Init() get instance of FairEventManager " << endl;

                if (fSttParameters->GetGeometryType() == 1) {
            PndSttMapCreator *mapper = new PndSttMapCreator(fSttParameters);
            fSttTubeArray = mapper->FillTubeArray();
                }

   }
   fStartFunctor = new StopTime();
   fStopFunctor = new StopTime();
//   fCrawler = new PndMCDataCrawler();
//   fCrawler->Init();
//   fCrawler->SetStoreIntermediate(kFALSE);

   if (IsActive())
                return kSUCCESS;
        else
                return kERROR;
}

// -----   Destructor   ----------------------------------------------------
PndSttIsochroneDraw::~PndSttIsochroneDraw()
{
        if (fStartFunctor != 0)
                delete (fStartFunctor);
        if (fStopFunctor != 0)
                delete (fStopFunctor);
}
// -------------------------------------------------------------------------
void PndSttIsochroneDraw::Exec(Option_t*)
{

        if (IsActive()) {

                if (fVerbose > 1)
                        cout << " PndSttIsochroneDraw::Exec " << endl;
                Reset();

                fListOfIsochrones = new TEveBoxSet("SttIsochrones");
                fListOfTiltedIsochrones = new TEveBoxSet("SttTiltedIsochrones");
                fListOfParallelIsochrones = new TEveBoxSet("SttParallelIsochrones");
                //fListOfTracks->DestroyElements();

                gEve->AddElement(fListOfIsochrones, fEventManager);
                fListOfIsochrones->AddElement(fListOfTiltedIsochrones);
                fListOfIsochrones->AddElement(fListOfParallelIsochrones);
                Double_t eventTime = FairRootManager::Instance()->GetEventTime();

                if (FairRunAna::Instance()->IsTimeStamp()) {
                        std::cout << "Inside TimeStamp" << std::endl;
                        if (fUseEventTime) {
                                fStartTime = eventTime - fTimeWindowMinus;
                        }
                        cout << "EventTime: " << eventTime << " TimeWindow: " << fStartTime
                                        << " - " << eventTime + fTimeWindowPlus << std::endl;

                        fSttHitArray = FairRootManager::Instance()->GetData(GetName(),
                                        fStartFunctor, fStartTime, fStopFunctor, eventTime + fTimeWindowPlus); //FairRootManager::Instance()->GetEventTime() +
                        std::cout << fStartTime << " " << eventTime + fTimeWindowPlus
                                        << " FoundTracks: " << fSttHitArray->GetEntriesFast()
                                        << std::endl;
                }

                std::cout << "SttHitArray: " << fSttHitArray->GetEntriesFast()
                                << std::endl;

                for (Int_t i = 0; i < fSttHitArray->GetEntriesFast(); i++) {
                        if (fVerbose > 2)
                                cout << "PndSttIsochroneDraw::Exec " << i << endl;

                        PndSttHit* myHit = (PndSttHit*) fSttHitArray->At(i);
                        std::cout << "STTHits: " << myHit->GetX() << " " << myHit->GetY()
                                        << " " << myHit->GetZ() << std::endl;
                        if (0 == myHit) {
                                std::cout << "-E- PndSttIsochroneDraw Hit does not exist! " << i
                                                << std::endl;
                                continue;
                        }

            PndSttTube* myTube = nullptr;
            if (fSttParameters->GetGeometryType() == 1){
                myTube = (PndSttTube*) fSttTubeArray->At(myHit->GetTubeID());
            } else if (fSttParameters->GetGeometryType() == 2){
                myTube = PndSttTubeMap::Instance()->GetTube(myHit->GetTubeID());
            }

            if (nullptr == myTube) {
                std::cout << "-E- PndSttIsochroneDraw Tube does not exist! "
                        << myHit->GetTubeID() << std::endl;
                continue;
            }

//                              std::cout << "Tube: " << myTube->GetHalfLength() << std::endl;

            Double_t tubeLengthHalf = myTube->GetHalfLength();
            Double_t radius = 0;
            Double_t radiusError = 0;
            if (fUseIsochroneTime == kTRUE) {
                PndSttSingleStraw straw;
                Double_t driftTime = myHit->GetTimeStamp() - eventTime;
                FairMultiLinkedData_Interface* linkData = (FairMultiLinkedData_Interface*)myHit; //fInputData->At(i);

                //fCrawler->Init();
                //fCrawler->SetStoreIntermediate(kFALSE);
                std::cout << "StartLink: " << *linkData << std::endl;
                FairMultiLinkedData result = linkData->GetLinksWithType(FairRootManager::Instance()->GetBranchId("STTPoint"));
                        //fCrawler->GetInfo(FairMultiLinkedData(*linkData), "STTPoint");

                std::cout << "Links: " << result << std::endl;
                if (result.GetNLinks() == 1 && result.GetLink(0).GetType() == FairRootManager::Instance()->GetBranchId("STTPoint")){
                    PndSttPoint* mcPoint = (PndSttPoint*)FairRootManager::Instance()->GetCloneOfLinkData(result.GetLink(0));
                    FairLink evtHeaderLink(-1, result.GetLink(0).GetEntry(), "EventHeader.", -1);
                    FairEventHeader* evtHeader = (FairEventHeader*)FairRootManager::Instance()->GetCloneOfLinkData(evtHeaderLink);
                    if (evtHeader != 0)
                        std::cout << "MCTime: " << evtHeader->GetEventTime() << std::endl;
                    std::cout << "MCRadius: " << mcPoint->GetTrueDistance() << std::endl;// << " MCTime: " << evtHeader->GetEventTime() << std::endl;
                    delete mcPoint;
                    delete evtHeader;
                }
                std::cout << "-I- PndSttIsochroneDraw Pulse: " << myHit->GetPulse() << " TimeStamp: " << myHit->GetTimeStamp() << " EventTime " << eventTime << " DriftTime: " << driftTime << std::endl;
                std::cout << "-I- PndSttIsochroneDraw Radius: " << myHit->GetIsochrone() << " RecoRadius: " << straw.TimnsToDiscm(driftTime) << std::endl;

                if (driftTime > 0) {
                    radius = straw.TimnsToDiscm(driftTime);
                } else {
                    std::cout << "-I- PndSttIsochrone Drift time <= 0: " << driftTime << std::endl;
                    continue;
                }
                if (radius > myTube->GetRadIn()) {
                    std::cout << "-I- PndSttIsochrone Isochrone with " << radius << " larger than tube radius of " << myTube->GetRadIn() << std::endl;
                    continue;
                }
                radiusError = myHit->GetIsochroneError();
            } else {
                radius = myHit->GetIsochrone();
                radiusError = myHit->GetIsochroneError();
            }
//                              std::cout << "RadiusError " << radiusError << std::endl;

            TEveGeoShape* myEveShape;
            myEveShape = new TEveGeoShape("SttTube");
            radiusError = 0.05;
            myEveShape->SetShape(
                    new TGeoTube(radius - radiusError, radius + radiusError,
                            tubeLengthHalf));
//                              std::cout << "Wire direction: " << myTube->GetWireDirection().X() << " "  << myTube->GetWireDirection().Y() << " "  << myTube->GetWireDirection().Z() << std::endl;
            if (myTube->GetWireDirection().Pt() > 0) {
                myEveShape->SetMainColor(kYellow);
                myEveShape->SetMainTransparency(80);
            } else {
                myEveShape->SetMainColor(kCyan);
            }
            TMatrixT<double> myRotMat = myTube->GetRotationMatrix();
            Double_t rotArray[9];
            rotArray[0] = myRotMat(0, 0);
            rotArray[1] = myRotMat(0, 1);
            rotArray[2] = myRotMat(0, 2);
            rotArray[3] = myRotMat(1, 0);
            rotArray[4] = myRotMat(1, 1);
            rotArray[5] = myRotMat(1, 2);
            rotArray[6] = myRotMat(2, 0);
            rotArray[7] = myRotMat(2, 1);
            rotArray[8] = myRotMat(2, 2);

            if (fVerbose > 1) {
                std::cout << "RotMat NElements: "
                        << myRotMat.GetNoElements() << std::endl;

                std::cout << myRotMat(0, 0) << " ";
                std::cout << myRotMat(0, 1) << " ";
                std::cout << myRotMat(0, 2) << std::endl;
                std::cout << myRotMat(1, 0) << " ";
                std::cout << myRotMat(1, 1) << " ";
                std::cout << myRotMat(1, 2) << std::endl;
                std::cout << myRotMat(2, 0) << " ";
                std::cout << myRotMat(2, 1) << " ";
                std::cout << myRotMat(2, 2) << std::endl;
            }

            TGeoHMatrix geoTrans;
            geoTrans.SetRotation(rotArray);
            Double_t trans[3];
            trans[0] = myTube->GetPosition().X();
            trans[1] = myTube->GetPosition().Y();
            trans[2] = myTube->GetPosition().Z();
            if (fSttParameters->GetGeometryType() == 2)
                trans[2] += tubeLengthHalf + 0.35;                             //< Todo: The origin of the tube is at the beginning of the tube and not at the center. Skewed straws still do not work.
            geoTrans.SetTranslation(trans);

            if (fVerbose > 1) {
                std::cout << "Translation: " << trans[0] << "/" << trans[1] << "/" << trans[2] << std::endl;
            }

            myEveShape->SetTransMatrix(geoTrans);
            if (radius > 0) {
                if (myTube->GetWireDirection().Pt() > 0) {
                    fListOfTiltedIsochrones->AddElement(myEveShape);
                }
                else {
                    fListOfParallelIsochrones->AddElement(myEveShape);
                }
            }
                }
                gEve->Redraw3D(kFALSE);
//              if (fListOfIsochrones) fListOfIsochrones->Delete();
//              if (fListOfTiltedIsochrones) fListOfTiltedIsochrones->Delete();
        }
}




// -------------------------------------------------------------------------
void PndSttIsochroneDraw::SetParContainers()
{
          FairRuntimeDb* rtdb = FairRunAna::Instance()->GetRuntimeDb();
          fSttParameters = (PndGeoSttPar*) rtdb->getContainer("PndGeoSttPar");
}

// -------------------------------------------------------------------------
void PndSttIsochroneDraw::Finish()
{

}
// -------------------------------------------------------------------------
void PndSttIsochroneDraw::Reset()
{

           if (fListOfTiltedIsochrones != 0) {
        //              fListOfTiltedIsochrones->Reset();
//                 gEve->PreDeleteElement(fListOfTiltedIsochrones);
//                      gEve->RemoveElement(fListOfTiltedIsochrones, fListOfIsochrones);
                        fListOfTiltedIsochrones->DestroyElements();
                        fListOfTiltedIsochrones->Destroy();
                }

        if (fListOfParallelIsochrones != 0){
//         fListOfIsochrones->Reset();
//         gEve->PreDeleteElement(fListOfParallelIsochrones);
//         gEve->RemoveElement(fListOfParallelIsochrones, fListOfIsochrones);
           fListOfParallelIsochrones->DestroyElements();
           fListOfParallelIsochrones->Destroy();

   }
        if (fListOfIsochrones != 0){
//         fListOfIsochrones->Reset();
//         gEve->PreDeleteElement(fListOfIsochrones);
//         gEve->RemoveElement(fListOfIsochrones, fEventManager);
           fListOfIsochrones->Destroy();
   }

}


void PndSttIsochroneDraw::SetTimeWindowMinus(Double_t val)
{
  fTimeWindowMinus = val;
}

void PndSttIsochroneDraw::SetTimeWindowPlus(Double_t val)
{
  fTimeWindowPlus = val;
}


ClassImp(PndSttIsochroneDraw)