PndHypGeoHandling.cxx

Go to the documentation of this file.

//
// C++ Implementation: PndGeoHandling
//
// Description: 
//
//
// Author: t.stockmanns <stockman@ikp455>, (C) 2007
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include "PndHypGeoHandling.h"
#include "PndStringVector.h"
#include <vector>
#include <string>
#include "PndStringVector.h"
#include "TROOT.h"
#include "TGeoManager.h"
#include "TGeoMatrix.h"
#include <math.h>
#include "TGeoShape.h"
#include "TGeoBBox.h"
#include "stdlib.h"

ClassImp(PndHypGeoHandling);

PndHypGeoHandling::PndHypGeoHandling()
{
        if (gROOT->FindObjectAny("FAIRGeom") == 0){
                std::cout << " -E- PndHypGeoHandling: No Geometry existing!" << std::endl;
                return;
        }
        fGeoMan = gGeoManager;fVerbose = 0;
}

PndHypGeoHandling::PndHypGeoHandling(TString fileName)
{
        if (gROOT->FindObjectAny("FAIRGeom") == 0){
    fGeoMan = new TGeoManager("geoMan","geoMan");
    fGeoMan->Import(fileName.Data());
        }
        fGeoMan = gGeoManager;fVerbose = 0;
}

TString PndHypGeoHandling::GetCurrentID()
{
  Int_t level;
  Int_t copyNr[100];
  Int_t volNr[100];
  TString result;
  
  level = fGeoMan->GetLevel();
  level++;
  
  fGeoMan->GetBranchNumbers(copyNr, volNr);
  for (int i=0; i<level; i++){
    result += volNr[i];
    result += "_";
    result += copyNr[i];
    result += "/";
  }     
  return result;
}

TString PndHypGeoHandling::GetID(TString path)
{
        TString result;
        TString currentPath = fGeoMan->GetPath();
        fGeoMan->cd(path.Data());
        result = GetCurrentID();
        fGeoMan->cd(currentPath.Data());
        return result;
}


TString PndHypGeoHandling::GetPath(TString id)
{
        TString result;
        std::vector<std::string> idVector;
        PndStringVector pathAna(id.Data(), "/_");
        idVector = pathAna.GetStringVector();
        
        for(Int_t i = 0; i < (int)idVector.size(); i+=2){
                result += "/";
                Int_t VolId = atoi(idVector[i].c_str());
                Int_t CopyNr = atoi(idVector[i+1].c_str());
                result += fGeoMan->GetVolume(VolId)->GetName();
                result += "_";
                result += CopyNr;
        }
        return result;
}

Bool_t PndHypGeoHandling::cd(TString id)
{
        return fGeoMan->cd(GetPath(id).Data());
}

TString PndHypGeoHandling::GetVolumeID(TString name)
{
        TString result;
        TGeoVolume* vol = fGeoMan->FindVolumeFast(name);
        if (vol == 0)
                return result;
        result += vol->GetNumber();
        return result;
}

std::vector<TString> PndHypGeoHandling::GetNamesLevel(Int_t level, TString startPath, bool ) // fullPath //[R.K.03/2017] unused variable(s)
{
        TString actPath = fGeoMan->GetPath();
        fLevelNames.clear();
  
        if (startPath == ""){
                fGeoMan->CdTop();
                fLevel = level;
        }
        else{
                if (fGeoMan->cd(startPath.Data())== 0)
                        return fLevelNames;
                else {
                        fLevel = fGeoMan->GetLevel() + level;
                }
        }
        FillLevelNames();
        return fLevelNames;
}

void PndHypGeoHandling::FillLevelNames()
{
        TGeoNode* myNode = fGeoMan->GetCurrentNode();
        if (fLevel == fGeoMan->GetLevel()){
                if (fFullPath)
                        fLevelNames.push_back(fGeoMan->GetPath());
                else
                        fLevelNames.push_back(myNode->GetName());
        }
        else {
                Int_t nDaughters = myNode->GetNdaughters();
                for (Int_t i = 0; i < nDaughters; i++){
                        fGeoMan->CdDown(i);
                        FillLevelNames();
                        fGeoMan->CdUp();        
                }
        }
}

void PndHypGeoHandling::GetOUVPath(TString path, TVector3& o, TVector3& u, TVector3& v)
{
        Double_t result[3];
        Double_t* temp;
        TString actPath = fGeoMan->GetPath();
        fGeoMan->cd(path);
        
        TGeoHMatrix* currMatrix = fGeoMan->GetCurrentMatrix();
        temp = currMatrix->GetTranslation();
        o.SetXYZ(temp[0], temp[1], temp[2]);
        
        temp[0] = 1;
        temp[1] = 0;
        temp[2] = 0;
        fGeoMan->LocalToMasterVect(temp, result);
        u.SetXYZ(result[0], result[1], result[2]);
        
        temp[0] = 0;
        temp[1] = 1;
        temp[2] = 0;
        fGeoMan->LocalToMasterVect(temp, result);
        v.SetXYZ(result[0], result[1], result[2]);
        if(actPath!="" && actPath!=" ") fGeoMan->cd(actPath);
}

void PndHypGeoHandling::GetOUVId(TString id, TVector3& o, TVector3& u, TVector3& v)
{
        GetOUVPath(GetPath(id),o,u,v);
}


TVector3 PndHypGeoHandling::GetSensorDimensionsPath(TString path)
{
  TVector3 dim;
  TString actPath = fGeoMan->GetPath();
  fGeoMan->cd(path);
  
  TGeoVolume* actVolume = gGeoManager->GetCurrentVolume();
  TGeoBBox* actBox = (TGeoBBox*)(actVolume->GetShape());
  dim.SetX(actBox->GetDX());
  dim.SetY(actBox->GetDY());
  dim.SetZ(actBox->GetDZ());
  
  if(actPath!="" && actPath!=" ") fGeoMan->cd(actPath);
  return dim;
}


TVector3 PndHypGeoHandling::GetSensorDimensionsID(TString id)
{
  return GetSensorDimensionsPath(GetPath(id));
}

//  ----- conversions of POINTS (not vectors) here -----
TVector3 PndHypGeoHandling::MasterToLocalId(const TVector3& master, const TString& id)
{ return MasterToLocalPath(master, GetPath(id) ); }

TVector3 PndHypGeoHandling::MasterToLocalPath(const TVector3& master, const TString& path)
{
        //   if(fVerbose>1) std::cout<<" -I- PndHypGeoHandling::MasterToLocalPath"<<std::endl;
  Double_t result[3];
  Double_t temp[3];
        
  temp[0] = master.X();
  temp[1] = master.Y();
  temp[2] = master.Z();
        
  TString actPath = fGeoMan->GetPath();
  fGeoMan->cd(path);
  fGeoMan->MasterToLocal(temp, result);
        //   fGeoMan->cd(actPath);
  if(actPath != "" && actPath != " ") fGeoMan->cd(actPath);  
  return TVector3(result[0],result[1],result[2]);
}



TVector3 PndHypGeoHandling::LocalToMasterId(const TVector3& local, const TString& id)
{ return LocalToMasterPath(local, GetPath(id) ); }

TVector3 PndHypGeoHandling::LocalToMasterPath(const TVector3& local, const TString& path)
{
  Double_t result[3];
  Double_t temp[3];
        
  temp[0] = local.X();
  temp[1] = local.Y();
  temp[2] = local.Z();
        
  TString actPath = fGeoMan->GetPath();
  fGeoMan->cd(path);
  fGeoMan->LocalToMaster(temp, result);
  fGeoMan->cd(actPath);
  if(actPath != "" && actPath != " ") fGeoMan->cd(actPath);
  return TVector3(result[0],result[1],result[2]);
}


// ROTATION of error values, CAUTION - these are always psitive defined
TVector3 PndHypGeoHandling::MasterToLocalErrorsId(const TVector3& master, const TString& id)
{ return MasterToLocalErrorsPath(master, GetPath(id) ); }

TVector3 PndHypGeoHandling::MasterToLocalErrorsPath(const TVector3& master, const TString& path)
{
  Double_t result[3];
  Double_t temp[3];
  TString actPath = fGeoMan->GetPath();
  fGeoMan->cd(path);
  
  
  temp[0] = master.X();
  temp[1] = master.Y();
  temp[2] = master.Z();
  
  // rotate "error vector"
  fGeoMan->MasterToLocalVect(temp,result);
  // positive error values
  for(Int_t i=0;i<3;i++) result[i]=fabs(result[i]);
  
  
        
  if(actPath != "" && actPath != " ") fGeoMan->cd(actPath);
  return TVector3(result[0],result[1],result[2]);
        
        
}



TVector3 PndHypGeoHandling::LocalToMasterErrorsId(const TVector3& local, const TString& id)
{ return LocalToMasterErrorsPath(local, GetPath(id) ); }

TVector3 PndHypGeoHandling::LocalToMasterErrorsPath(const TVector3& local, const TString& path)
{
  Double_t result[3];
  Double_t tmp[3];
  TString actPath = fGeoMan->GetPath();
  fGeoMan->cd(path);
        
        
  tmp[0] = local.X();
  tmp[1] = local.Y();
  tmp[2] = local.Z();
        
  // rotate "error vector"
  fGeoMan->LocalToMasterVect(tmp,result);
  // positive error values
  for(Int_t i=0;i<3;i++) result[i]=fabs(result[i]);
        
  if(actPath != "" && actPath != " ") fGeoMan->cd(actPath);
  return TVector3(result[0],result[1],result[2]);
        
}