FairModule.h

Go to the documentation of this file.

/********************************************************************************
 *    Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH    *
 *                                                                              *
 *              This software is distributed under the terms of the             *
 *              GNU Lesser General Public Licence (LGPL) version 3,             *
 *                  copied verbatim in the file "LICENSE"                       *
 ********************************************************************************/
#ifndef FAIRMODULE_H
#define FAIRMODULE_H

#include "FairGeoInterface.h"   // for FairGeoInterface
#include "FairGeoLoader.h"      // for FairGeoLoader
#include "FairGeoNode.h"        // for FairGeoNode
#include "FairGeoVolume.h"      // for FairGeoVolume
#include "FairLogger.h"
#include "FairRun.h"         // for FairRun
#include "FairRuntimeDb.h"   // for FairRuntimeDb

#include <Rtypes.h>      // for Bool_t, Int_t, etc
#include <TList.h>       // for TList (ptr only), TListIter
#include <TNamed.h>      // for TNamed
#include <TObjArray.h>   // for TObjArray
#include <TString.h>     // for TString, operator!=
#include <string>        // for string

class FairVolumeList;
class FairVolume;
class TArrayI;
class TGeoMatrix;
class TGeoNode;
class TGeoVolume;
class TRefArray;
class TVirtualMC;

class FairModule : public TNamed
{
  public:
    FairModule();
    FairModule(const char* Name, const char* title, Bool_t Active = kFALSE);
    virtual ~FairModule();
    virtual void Print(Option_t*) const { ; }
    virtual void SetGeometryFileName(TString fname, TString geoVer = "0");
    virtual TString GetGeometryFileName() { return fgeoName; }
    virtual TString GetGeometryFileVer() { return fgeoVer; }
    virtual void ConstructGeometry();
    virtual void ConstructOpGeometry();
    virtual void ConstructRootGeometry(TGeoMatrix* shiftM = nullptr);
    virtual void ConstructASCIIGeometry();
    virtual void ModifyGeometry()
        __attribute__((deprecated("Use FairAlignmentHandler instead, see Tutorial4 for examples")))
    {
        LOG(warn) << "This function is deprecated. Use FairAlignmentHandler instead, see Tutorial4 for examples.";
    }
    virtual void RegisterAlignmentMatrices() { ; }

    virtual void ConstructGDMLGeometry(__attribute__((unused)) TGeoMatrix* posrot);
    virtual void SetSpecialPhysicsCuts() { ; }
    virtual FairModule* CloneModule() const;
    virtual void BeginWorkerRun() const { ; }
    virtual void FinishWorkerRun() const { ; }

    template<class T, class U>
    void ConstructASCIIGeometry(T* dataType1, TString containerName = "", U* datatype2 = nullptr);

    virtual Bool_t IsSensitive(const std::string& name);
    virtual Bool_t CheckIfSensitive(__attribute__((unused)) std::string name) __attribute__((
        deprecated("The method CheckIfSensitive is deprecated. Implement IsSensitive in the detector classes.")))
    {
        return kFALSE;
    }
    virtual void ExpandNode(TGeoNode* Node);
    virtual void ExpandNodeForGDML(__attribute__((unused)) TGeoNode* curNode);
    virtual Int_t getVolId(const TString&) const { return 0; }
    Int_t GetModId() { return fModId; }
    void SetVerboseLevel(Int_t level) { fVerboseLevel = level; }
    Bool_t IsActive() { return fActive; }
    void SetModId(Int_t id) { fModId = id; }
    void SetMotherVolume(TString volName) { fMotherVolumeName = volName; }
    void ProcessNodes(TList* aList);
    virtual void SetParContainers() { ; }
    virtual void InitParContainers() { ; }
    TList* GetListOfGeoPar() { return flGeoPar; }

    static thread_local FairVolumeList* vList;   

    static thread_local Int_t fNbOfVolumes;   

    static thread_local TRefArray* svList;   

    static thread_local TArrayI* volNumber;   
    TString fMotherVolumeName;                
    FairVolume* getFairVolume(FairGeoNode* fNode);
    void AddSensitiveVolume(TGeoVolume* v);

  private:
    void SetDefaultMatrixName(TGeoMatrix* matrix);
    void AssignMediumAtImport(TGeoVolume* v);   // O.Merle, 29.02.2012 - see impl.

    void ReAssignMediaId();
    void swap(FairModule& other) throw();

  protected:
    FairModule(const FairModule&);
    FairModule& operator=(const FairModule&);
    TString fgeoVer;
    TString fgeoName;
    Int_t fModId;
    Bool_t fActive;
    Int_t fNbOfSensitiveVol;   
    Int_t fVerboseLevel;
    TList* flGeoPar;    
    Bool_t fGeoSaved;   
    TVirtualMC* fMC;    

    ClassDef(FairModule, 4);
};

template<class T, class U>
void FairModule::ConstructASCIIGeometry(T* dataType1, TString containerName, U*)
{
    FairGeoLoader* loader = FairGeoLoader::Instance();
    FairGeoInterface* GeoInterface = loader->getGeoInterface();
    T* MGeo = new T();
    MGeo->print();
    MGeo->setGeomFile(GetGeometryFileName());
    GeoInterface->addGeoModule(MGeo);
    Bool_t rc = GeoInterface->readSet(MGeo);
    if (rc) {
        MGeo->create(loader->getGeoBuilder());
    }

    TList* volList = MGeo->getListOfVolumes();
    // store geo parameter
    FairRun* fRun = FairRun::Instance();
    FairRuntimeDb* rtdb = FairRun::Instance()->GetRuntimeDb();

    dataType1 = MGeo;

    if ("" != containerName) {
        LOG(info) << "Add GeoNodes for " << MGeo->getDescription() << " to container " << containerName;

        //    U par=(U)(rtdb->getContainer(containerName));
        U* par = static_cast<U*>(rtdb->getContainer(containerName));
        TObjArray* fSensNodes = par->GetGeoSensitiveNodes();
        TObjArray* fPassNodes = par->GetGeoPassiveNodes();

        TListIter iter(volList);
        FairGeoNode* node = nullptr;
        FairGeoVolume* aVol = nullptr;

        while ((node = static_cast<FairGeoNode*>(iter.Next()))) {
            aVol = dynamic_cast<FairGeoVolume*>(node);
            if (node->isSensitive()) {
                fSensNodes->AddLast(aVol);
            } else {
                fPassNodes->AddLast(aVol);
            }
        }
        ProcessNodes(volList);
        par->setChanged();
        par->setInputVersion(fRun->GetRunId(), 1);
    }
}

#endif   // FAIRMODULE_H