BmnZdcDigiScheme.cxx

Go to the documentation of this file.

/*************************************************************************************
 *
 *         Class BmnZdcDigiScheme
 *
 *  Author:   Elena Litvinenko
 *  e-mail:   litvin@nf.jinr.ru
 *  Version:  18-11-2015
 *
 ************************************************************************************/
 
#include "BmnZdcDigiScheme.h"
 
#include "TGeoBBox.h"
#include "TGeoManager.h"
#include "TGeoNode.h"
 
#include <iostream>
 
using std::cout;
using std::endl;
 
BmnZdcDigiScheme* BmnZdcDigiScheme::fInstance = 0;
Bool_t BmnZdcDigiScheme::fInitialized = 0;
Int_t BmnZdcDigiScheme::fRefcount = 0;
 
static Int_t kZDC = 1;   //  // hard-coded basic ZDC detector number
 
// -------------------------------------------------------------------------
 
BmnZdcDigiScheme::BmnZdcDigiScheme()
    : Nx(0)
    , Ny(0)
    , Nz(0)
{
    fZdcDigiPar = 0;
}
 
// -------------------------------------------------------------------------
 
BmnZdcDigiScheme::~BmnZdcDigiScheme()
{
    fRefcount--;
    if (!fRefcount) {
        delete this;
        fInstance = NULL;
    }
}
// -------------------------------------------------------------------------
 
BmnZdcDigiScheme* BmnZdcDigiScheme::Instance()
{
    if (!fInstance)
        fInstance = new BmnZdcDigiScheme();
    fRefcount++;
    return fInstance;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::Init(BmnZdcGeoPar* geoPar, BmnZdcDigiPar* digiPar, Int_t pVerbose)
{
    if (!fInitialized) {
 
        if (!geoPar) {
            cout << "-W- BmnZdcDigiScheme::Init: "
                 << "No geometry parameters available!" << endl;
            return kFALSE;
        }
        if (!digiPar) {
            cout << "-W-  BmnZdcDigiScheme::Init: "
                 << "No digitization parameters available!" << endl;
            //      return kFALSE;
        }
        fZdcDigiPar = digiPar;
 
        TObjArray* sensNodes = geoPar->GetGeoSensitiveNodes();
        if (!sensNodes) {
            cout << "-W-  BmnZdcDigiScheme::Init: "
                 << "No sensitive nodes available!" << endl;
            return kFALSE;
        }
 
        fPasNodes = geoPar->GetGeoPassiveNodes();
        if (!fPasNodes) {
            cout << "-W-  BmnZdcDigiScheme::Init: "
                 << "No passive nodes available!" << endl;
            return kFALSE;
        }
 
        fInitialized = kTRUE;
 
        AddNodes(sensNodes, pVerbose);
        CalcDimensions(kZDC, Nx, Ny, Nz);
 
        if (pVerbose)
            cout << endl << "-W-  BmnZdcDigiScheme::Init: finished." << endl;
    }
    return kTRUE;
}
 
// -------------------------------------------------------------------------
 
BmnZdcVolInfo_t* BmnZdcDigiScheme::CreateVolInfoElement(FairGeoNode* nod, Int_t pVerbose)
{
    if (!nod)
        return NULL;
 
    static TString root_name_copy1 = "";
    static Double_t volData[6] = {0, 0, 0, 0, 0, 0};
    Int_t i;
 
    TString shape_name = nod->getShapePointer()->GetName();
    TString root_name = nod->getRootVolume()->GetName();
    TString tmp = "          ";
    TGeoBBox* shape = 0;
 
    FairGeoVector pos = nod->getLabTransform()->getTranslation();
 
    for (i = 0; i < 3; i++)
        volData[i] = pos.getValues(i);   // [cm]
 
    if (root_name != root_name_copy1) {
 
        root_name_copy1 = root_name;
 
        shape = (TGeoBBox*)nod->getRootVolume()->GetShape();
 
        if (shape_name.Contains("BOX")) {
            volData[3] = shape->GetDX();   // [cm]
            volData[4] = shape->GetDY();   // [cm]
            volData[5] = shape->GetDZ();   // [cm]
        } else {
            if (shape_name.Contains("PGON")) {
                volData[3] = nod->getPoint(2)->getZ() / 10.;   // [cm]
                volData[4] = volData[3];
                volData[5] = shape->GetDZ();   // [cm]
            }
        }
    }
 
    BmnZdcVolInfo_t* volInfo = new BmnZdcVolInfo_t;
    for (i = 0; i < 6; i++)
        volInfo->push_back(volData[i]);
 
    if (pVerbose > 1) {
        if (pVerbose > 2)
            tmp = "  root: " + root_name + ", shape: " + shape_name;
        tmp += "X,Y,Z,   Dx,Dy,Dz: ";
        cout << tmp << volData[0] << "," << volData[1] << "," << volData[2] << ",   " << volData[3] << "," << volData[4]
             << "," << volData[5] << endl;
    }
    return volInfo;
}
 
// -------------------------------------------------------------------------
 
BmnZdcVolId_t* BmnZdcDigiScheme::CreateVolElement(FairGeoNode* nod,
                                                  Int_t nodeNumber,
                                                  BmnZdcDigiId_t* right,
                                                  Int_t pVerbose)
{
    if (!nod)
        return NULL;
 
    // FairGeoNode *nod0, *nod1;
    TString mother_name, tmp;
 
    //  FairGeoTransform *center;
 
    TString nod_name = nod->GetName();
    mother_name = nod->getMother();
 
    //  if (nod_name.Contains("boxs") {
    if (1) {
 
        //   (*right).push_back(nod->getRootVolume()->GetNumber()); // GroupID(now=box volume ID)
        if (nod_name.Contains("boxs"))
            (*right).push_back(1);   //  GroupID ("size" of small ZDC module)
        else
            (*right).push_back(2);              //  GroupID ("size" of big ZDC module)
        (*right).push_back(nod->getCopyNo());   // ModuleID inside group
        //   center = nod->getLabTransform();
        (*right).push_back(nodeNumber);   // ChannelID
 
        BmnZdcVolId_t* left = new BmnZdcVolId_t;
        (*left).push_back(nod->getRootVolume()->GetNumber() + 3);   // sensitive volume ID
        (*left).push_back(nod->getCopyNo());                        // MotherMotherCopyNo
 
        if (pVerbose > 1) {
            tmp = "  mother: " + mother_name + ", me: " + (nod->getName()) + "    ";
            cout << tmp << (*left)[0] << "," << (*left)[1] << " : " << (*right)[0] << "," << (*right)[1] << ","
                 << (*right)[2] << endl;
        }
 
        return left;
 
    } else {
        cout << "-E-  BmnZdcDigiScheme::CreateVolInfoElement:  Strange for me node: " << nod->GetName()
             << "  Node number:" << nodeNumber << "  Mother:" << mother_name << endl;
        return NULL;
    }
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::AddNodes(TObjArray* sensNodes, Int_t pVerbose)
{
    // Int_t nNodes = sensNodes->GetEntriesFast();
    Int_t nPasNodes = fPasNodes->GetEntriesFast();
    FairGeoNode* nod = 0;
    Int_t nodeNumber, /*nodeCopyNo,nodeVolumeId, chanId2=0, chanId1=0, */ zdc_channel = 0;
    BmnZdcVolId_t* left1 /*,*left2*/;
    BmnZdcDigiId_t* right1 /*,*right2*/;
 
    // if (pVerbose) {
    //     cout << "-W-  BmnZdcDigiScheme::AddNodes: started.  nNodes:" << nNodes  << endl;
    // }
 
    // for (nodeNumber=0;nodeNumber<nNodes;nodeNumber++) {
 
    if (pVerbose) {
        //      cout << "-W-  BmnZdcDigiScheme::AddNodes: started.  nNodes:" << nNodes  << endl;
        cout << "-W-  BmnZdcDigiScheme::AddNodes: started.  nNodes:" << nPasNodes << endl;
    }
 
    TString nod_name;
 
    for (nodeNumber = 1; nodeNumber < nPasNodes; nodeNumber++) {
        //    nod = (FairGeoNode*)sensNodes->At(nodeNumber);
        nod = (FairGeoNode*)fPasNodes->At(nodeNumber);   // we will use boxes, not layers
        if (nod) {
 
            nod_name = nod->getName();
            if (nod_name.Contains("box")) {
 
                zdc_channel++;
 
                right1 = new BmnZdcDigiId_t;
                //  left1 = CreateVolElement(nod, nodeNumber, right1, pVerbose);
                left1 = CreateVolElement(nod, zdc_channel, right1, pVerbose);
 
                fVolToDigiIdMap[*left1] = *right1;
 
                CreateVolInfoElement(nod, 1);
                // left2 = new BmnZdcVolId_t ((*left1).begin(),(*left1).end());
                // (*left2)[0]=(*left1)[0]+1;
                // right2 = new BmnZdcDigiId_t (right1->begin(),right1->end());
                // (*right2)[0] = (*right1)[0]+1;
 
                // fVolToDigiIdMap[*left2]=*right2;
 
                // CreateVolCopyElements (left1, right1);
            }
 
        } else {
            cout << "-W-  BmnZdcDigiScheme::AddNodes: "
                 //    << "Node number "<< nodeNumber << " from " << nNodes  << " not found!" << endl;
                 << "Node number " << nodeNumber << " from " << nPasNodes << " not found!" << endl;
            return kFALSE;
        }
    }
    return kTRUE;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::CreateVolCopyElements(BmnZdcVolId_t* left, BmnZdcDigiId_t* right)
{
    BmnZdcVolId_t* left1 /*,*left2*/;
    BmnZdcDigiId_t* right1 /*,*right2*/;
 
    if (!fPasNodes)
        return kFALSE;
 
    FairGeoNode* nod1 = (FairGeoNode*)fPasNodes->At(fPasNodes->GetEntries() - 2);
 
    if (!nod1)
        return kFALSE;
 
    Int_t moduleID, nModules;   // {MotherMotherCopyNo, MotherCopyNo, VolumeId, CopyNo},{GroupID, ModuleID, ChannelID}
 
    TString lm_name = nod1->getName();
    TString last_module_number(&(lm_name[lm_name.Last('#') + 1]));
    nModules = last_module_number.Atoi();
 
    for (moduleID = 1; moduleID < nModules; moduleID++) {
 
        left1 = new BmnZdcVolId_t((*left).begin(), (*left).end());
        (*left1)[1] = (*left)[1] + moduleID;
        right1 = new BmnZdcDigiId_t(right->begin(), right->end());
        (*right1)[1] = (*right)[1] + moduleID;
 
        fVolToDigiIdMap[*left1] = *right1;
    }
 
    return kTRUE;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::CreateVolInfoCopyElements(BmnZdcDigiId_t* right, BmnZdcVolInfo_t* volInfo)
{
 
    if (!fPasNodes)
        return kFALSE;
 
    FairGeoNode* nod1 = (FairGeoNode*)fPasNodes->At(fPasNodes->GetEntries() - 2);
 
    if (!nod1)
        return kFALSE;
 
    Int_t moduleID, nModules;
 
    TString lm_name = nod1->getName();
    TString last_module_number(&(lm_name[lm_name.Last('#') + 1]));
    nModules = last_module_number.Atoi();
 
    for (moduleID = 1; moduleID < nModules; moduleID++) {
 
        nod1 = (FairGeoNode*)fPasNodes->At(fPasNodes->GetEntries() - 2 - nModules + moduleID);
 
        FairGeoVector pos = nod1->getLabTransform()->getTranslation();
 
        BmnZdcVolInfo_t* volInfo1 = new BmnZdcVolInfo_t((*volInfo).begin(), (*volInfo).end());
        (*volInfo1)[0] = pos.getValues(0);   // X [cm]
        (*volInfo1)[1] = pos.getValues(1);   // Y [cm]
 
        BmnZdcDigiId_t* right1 = new BmnZdcDigiId_t(right->begin(), right->end());
        (*right1)[1] = (*right)[1] + moduleID;
 
        BmnZdcDigiId_t* right2 = new BmnZdcDigiId_t(right1->begin(), right1->end());
        (*right2)[0] = (*right1)[0] + 1;
 
        BmnZdcVolInfo_t* volInfo2 = new BmnZdcVolInfo_t(*volInfo1);
        (*volInfo2)[2] = -(*volInfo2)[2];   // Z [cm]
 
        fDigiToVolInfoMap[*right1] = volInfo1;
        fDigiToVolInfoMap[*right2] = volInfo2;
    }
 
    return kTRUE;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::GetVolCenterXYZ(BmnZdcDigiId_t* pDigiID, Double_t& x, Double_t& y, Double_t& z)
{
    if (!pDigiID)
        return kFALSE;
    if (fDigiToVolInfoMap.find(*pDigiID) == fDigiToVolInfoMap.end())
        return kFALSE;
    else {
        BmnZdcVolInfo_t* volInfo = fDigiToVolInfoMap[*pDigiID];
        if (volInfo) {
            x = (*volInfo)[0];
            y = (*volInfo)[1];
            z = (*volInfo)[2];
            return kTRUE;
        } else
            return kFALSE;
    }
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::GetVolDxDyDz(BmnZdcDigiId_t* pDigiID, Double_t& Dx, Double_t& Dy, Double_t& Dz)
{
    if (!pDigiID)
        return kFALSE;
    if (fDigiToVolInfoMap.find(*pDigiID) == fDigiToVolInfoMap.end())
        return kFALSE;
    else {
        BmnZdcVolInfo_t* volInfo = fDigiToVolInfoMap[*pDigiID];
        if (volInfo) {
            Dx = (*volInfo)[3];
            Dy = (*volInfo)[4];
            Dz = (*volInfo)[5];
            return kTRUE;
        } else
            return kFALSE;
    }
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::IsVolumeExist(BmnZdcVolId_t* pVolId)
{
    if (!pVolId)
        return kFALSE;
    else
        return (!(fVolToDigiIdMap.find(*pVolId) == fVolToDigiIdMap.end()));
}
 
// -------------------------------------------------------------------------
 
BmnZdcDigiId_t BmnZdcDigiScheme::GetDigiId(BmnZdcVolId_t* pVolId)
{
    static const BmnZdcDigiId_t not_found(4, -1);
 
    if (IsVolumeExist(pVolId))
        return fVolToDigiIdMap[*pVolId];
    else
        return not_found;
}
 
// -------------------------------------------------------------------------
 
Int_t BmnZdcDigiScheme::GetGroupID(BmnZdcVolId_t* pVolId)
{
    BmnZdcDigiId_t digiID = GetDigiId(pVolId);
    //  return digiID.first;
    return digiID[0];
}
 
// -------------------------------------------------------------------------
 
Int_t BmnZdcDigiScheme::GetChannelID(BmnZdcVolId_t* pVolId)
{
    BmnZdcDigiId_t digiID = GetDigiId(pVolId);
    //  return digiID.second;
    return digiID[2];
}
 
// -------------------------------------------------------------------------
 
BmnZdcVolInfo_t* BmnZdcDigiScheme::GetVolInfo(BmnZdcVolId_t* pVolId)
{
    if (IsVolumeExist(pVolId)) {
 
        BmnZdcDigiId_t pDigiID = GetDigiId(pVolId);
 
        if (fDigiToVolInfoMap.find(pDigiID) == fDigiToVolInfoMap.end())
            return NULL;
        else
            return fDigiToVolInfoMap[pDigiID];
    } else
        return NULL;
}
 
// -------------------------------------------------------------------------
 
void BmnZdcDigiScheme::PrintVolume(Int_t volID, Int_t copyNoMotherMother)
{
    Int_t content[] = {volID, copyNoMotherMother};
    BmnZdcVolId_t pVolId(content, content + sizeof(content) / sizeof(Int_t));
 
    BmnZdcDigiId_t pDigiID = GetDigiId(&pVolId);
 
    cout << " BmnZdc Volume: " << volID << "," << copyNoMotherMother << "   DigiID: " << pDigiID[0] << "," << pDigiID[1]
         << "," << pDigiID[2];
 
    if (IsVolumeExist(&pVolId))
        cout << " found ";
 
    BmnZdcVolInfo_t* pVolInfo = GetVolInfo(&pVolId);
 
    if (pVolInfo)
        cout << "    X,Y,Z [cm]: " << (*pVolInfo)[0] << "," << (*pVolInfo)[1] << "," << (*pVolInfo)[2]
             << "    Dx,Dy,Dz [cm]: " << (*pVolInfo)[3] << "," << (*pVolInfo)[4] << "," << (*pVolInfo)[5];
    else
        cout << " (no VolInfo) ";
 
    cout << endl;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::CalcDimensions(Int_t pGlobalDetectorNumber, Int_t& nx, Int_t& ny, Int_t& nz)
{
 
    if (fDigiToVolInfoMap.empty())
        return kFALSE;
 
    Bool_t result = kFALSE;
    std::map<BmnZdcDigiId_t, BmnZdcVolInfo_t*>::iterator it;
    std::map<Double_t, Int_t> xmap, ymap, zmap;
    Double_t x, y, z;
    nx = ny = nz = 0;
 
    for (it = fDigiToVolInfoMap.begin(); it != fDigiToVolInfoMap.end(); ++it) {
 
        //    cout << ". ";
 
        //    if ((*it).first.first==pGlobalDetectorNumber) {
        //    if ((*it).first[0]==1) {
        if (1) {
 
            result = kTRUE;
 
            x = (*((*it).second))[0];
            if (xmap.count(x))
                xmap[x] = xmap[x] + 1;
            else
                xmap[x] = 1;
 
            y = (*((*it).second))[1];
            if (ymap.count(y))
                ymap[y] = ymap[y] + 1;
            else
                ymap[y] = 1;
 
            z = (*((*it).second))[2];
            if (zmap.count(z))
                zmap[z] = zmap[z] + 1;
            else
                zmap[z] = 1;
        }
    }
 
    nx = xmap.size();
    ny = ymap.size();
    nz = zmap.size();
 
    return result;
}
 
// -------------------------------------------------------------------------
 
void BmnZdcDigiScheme::GetZdcDimensions(Int_t& nx, Int_t& ny, Int_t& nz)
{
    nx = Nx;
    ny = Ny;
    nz = Nz;
}
 
// -------------------------------------------------------------------------
 
BmnZdcDigiId_t BmnZdcDigiScheme::GetDigiIdFromCoords(Double_t x, Double_t y, Double_t z)
{
    Int_t content[] = {-1, -1};
    BmnZdcVolId_t resultmc(content, content + sizeof(content) / sizeof(Int_t));
 
    BmnZdcDigiId_t result(-1, -1);
    if (gGeoManager) {
        TGeoNode* tgn = gGeoManager->FindNode(x, y, z);
        if (tgn) {
            resultmc[0] = (gGeoManager->GetMother(2))->GetNumber();
            resultmc[1] = (gGeoManager->GetMother(1))->GetMotherVolume()->GetNumber();
            resultmc[2] = tgn->GetVolume()->GetNumber();
            resultmc[3] = tgn->GetNumber();
            if (fVolToDigiIdMap.find(resultmc) != fVolToDigiIdMap.end())
                result = fVolToDigiIdMap[resultmc];
        }
    }
    return result;
}
 
// -------------------------------------------------------------------------
 
BmnZdcDigiId_t BmnZdcDigiScheme::GetDigiIdFromVolumeData(Int_t pMcVolumeNumber, Int_t pMotherMotherCopyNumber)
{
    Int_t content[] = {pMcVolumeNumber, pMotherMotherCopyNumber};
    BmnZdcVolId_t pVolId(content, content + sizeof(content) / sizeof(Int_t));
    BmnZdcDigiId_t digiID = GetDigiId(&pVolId);
    return digiID;
}
 
// -------------------------------------------------------------------------
 
void BmnZdcDigiScheme::SplitDigiID(BmnZdcDigiId_t digiID, Int_t& module_groupID, Int_t& modID, Int_t& chanID)
{
    module_groupID = digiID[0];
    modID = digiID[1];
    chanID = digiID[2];
}
 
// -------------------------------------------------------------------------
 
void BmnZdcDigiScheme::Print()
{
    cout << "*********************************************" << endl;
 
    cout << "***  BmnZdcDigiScheme:" << endl;
    cout << " BmnZdc  Nx,Ny,Nz:  " << Nx << "," << Ny << "," << Nz;
 
    std::map<BmnZdcVolId_t, BmnZdcDigiId_t>::iterator it;
 
    for (it = fVolToDigiIdMap.begin(); it != fVolToDigiIdMap.end(); ++it)
        PrintVolume((*it).first[0], (*it).first[1]);
 
    cout << "*********************************************" << endl;
}
 
// -------------------------------------------------------------------------
 
Bool_t BmnZdcDigiScheme::GetGroupIdModIdChanId(Int_t pMcVolumeNumber,
                                               Int_t pMcCopyNumber,
                                               Int_t pMotherCopyNumber,
                                               Int_t pMotherMotherCopyNumber,
                                               Int_t& pGroupId,
                                               Int_t& pChanId,
                                               Int_t& pModId)
{
    Int_t content[] = {pMotherMotherCopyNumber, pMotherCopyNumber, pMcVolumeNumber, pMcCopyNumber};
    BmnZdcVolId_t pVolId(content, content + sizeof(content) / sizeof(Int_t));
    BmnZdcDigiId_t digiID = GetDigiId(&pVolId);
    pGroupId = digiID[0];
    pModId = digiID[1];
    pChanId = digiID[2];
 
    return kTRUE;
}