G4MultiSensitiveDetector.cc

Go to the documentation of this file.

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
// G4MultiSensitiveDetector

#include "G4MultiSensitiveDetector.hh"
#include "G4SDManager.hh"
#include <sstream>

//#define MSDDEBUG
#ifdef MSDDEBUG
#define DBG( msg ) G4cout<<msg<<G4endl
#else
#define DBG( msg )
#endif
#define VDBG( vl , msg ) if ( vl<=verboseLevel ) G4cout<<msg<<G4endl

G4MultiSensitiveDetector::G4MultiSensitiveDetector(G4String name)
        : G4VSensitiveDetector(name)
{
#ifdef MSDDEBUG
        verboseLevel = 3;
#endif
        VDBG(1,"Creating G4MultiSenstiveDetector with name: "<<name);
}

G4MultiSensitiveDetector::~G4MultiSensitiveDetector()
{
        VDBG(2,GetName()<<" : Destructing G4MultiSensitiveDetector");
        ClearSDs();
}

G4MultiSensitiveDetector::G4MultiSensitiveDetector(const G4MultiSensitiveDetector& rhs)
: G4VSensitiveDetector(rhs) ,
  fSensitiveDetectors(rhs.fSensitiveDetectors)
{
        VDBG(3,GetName()<<" : Copy constructor called.");
}

G4MultiSensitiveDetector&
G4MultiSensitiveDetector::operator=(const G4MultiSensitiveDetector& rhs)
{
        if ( this != &rhs ) {
                //G4VSensitiveDetector::operator=(static_cast<const G4VSensitiveDetector&>(rhs));
                G4VSensitiveDetector::operator=(static_cast<const G4VSensitiveDetector&>(rhs));
                fSensitiveDetectors = rhs.fSensitiveDetectors;
        }
        return *this;
}

void
G4MultiSensitiveDetector::Initialize(G4HCofThisEvent* )
{
    //SDManager is resposnsible for calling this since the granular SDs
  // are also registered
        //for ( auto sd : fSensitiveDetectors ) sd->Initialize(hcte);
}

void
G4MultiSensitiveDetector::EndOfEvent(G4HCofThisEvent* )
{
  //SDManager is resposnsible for calling this since the granular SDs
// are also registered
        //for ( auto sd : fSensitiveDetectors ) sd->EndOfEvent(hcte);
}

void
G4MultiSensitiveDetector::clear()
{
        for ( auto sd : fSensitiveDetectors ) sd->clear();
}

void
G4MultiSensitiveDetector::DrawAll()
{
        for ( auto sd : fSensitiveDetectors ) sd->DrawAll();
}

void
G4MultiSensitiveDetector::PrintAll()
{
        for ( auto sd : fSensitiveDetectors ) sd->PrintAll();
}

G4bool
G4MultiSensitiveDetector::ProcessHits(G4Step*aStep,G4TouchableHistory*)
{
        VDBG(2,GetName()<<" : Called processHits: "<<aStep<<" with Edep: "<<aStep->GetTotalEnergyDeposit());
        G4bool result = true;
        for (auto sd : fSensitiveDetectors )
                result &= sd->Hit(aStep);
        return result;
}

G4int G4MultiSensitiveDetector::GetCollectionID(G4int)
{
        G4ExceptionDescription msg;
        msg << GetName()<<" : This method cannot be called for an instance of type G4MultiSensitiveDetector."
                << " First retrieve a contained G4VSensitiveDetector with. i.e. GetSD and then "
                << " call this method.";
        G4Exception("G4MultiSensitiveDetector::GetCollectionID","Det0011",FatalException,msg);
        return -1;
}

//This method requires all contained SD to be clonable
G4VSensitiveDetector* G4MultiSensitiveDetector::Clone() const
{
        VDBG(2,GetName()<<"Cloning an instance of G4MultiSensitiveDetector");
        G4MultiSensitiveDetector* newInst = new G4MultiSensitiveDetector(this->GetName());
        for ( auto sd : fSensitiveDetectors )
                newInst->AddSD( sd->Clone() );
        return newInst;
}

void G4MultiSensitiveDetector::AddSD(G4VSensitiveDetector* sd) 
{ 
  // making sure this sensitive detector is registered to G4SDManager
  G4SDManager::GetSDMpointer()->AddNewDetector(sd);
  fSensitiveDetectors.push_back(sd);
}