Dicom2Run Class Reference

Dicom2Run class. More...

#include <Dicom2Run.hh>

Inheritance diagram for Dicom2Run:

Public Types
typedef G4VTHitsVector< G4StatAnalysis, std::vector< G4StatAnalysis > >	Dicom2RunVector

Public Member Functions
	Dicom2Run ()
	(Description) Dicom2Run Class is for accumulating scored quantities which is scored using G4MutiFunctionalDetector and G4VPrimitiveScorer.
	Dicom2Run (const std::vector< G4String > mfdName)
virtual	~Dicom2Run ()
virtual void	RecordEvent (const G4Event *)
size_t	GetNumberOfHitsMap () const
Dicom2RunVector *	GetHitsVector (G4int i) const
Dicom2RunVector *	GetHitsVector (const G4String &detName, const G4String &colName) const
Dicom2RunVector *	GetHitsVector (const G4String &fullName) const
void	ConstructMFD (const std::vector< G4String > &)
virtual void	Merge (const G4Run *)
Public Member Functions inherited from DicomRun
	DicomRun ()
	(Description) DicomRun Class is for accumulating scored quantities which is scored using G4MutiFunctionalDetector and G4VPrimitiveScorer.
	DicomRun (const std::vector< G4String > mfdName)
virtual	~DicomRun ()
size_t	GetNumberOfHitsMap () const
G4THitsMap< G4double > *	GetHitsMap (G4int i) const
G4THitsMap< G4double > *	GetHitsMap (const G4String &detName, const G4String &colName) const
G4THitsMap< G4double > *	GetHitsMap (const G4String &fullName) const
void	ConstructMFD (const std::vector< G4String > &)

Private Attributes
std::vector< G4String >	fCollName
std::vector< G4int >	fCollID
std::vector< Dicom2RunVector * >	fRunMap

Detailed Description

Dicom2Run class.

Demonstrates how to use G4StatAnalysis as a vector of objects (instead of vector of pointers to objects) to reduce memory consumption

Definition at line 52 of file Dicom2Run.hh.

Member Typedef Documentation

Dicom2RunVector

typedef G4VTHitsVector<G4StatAnalysis, std::vector<G4StatAnalysis> > Dicom2Run::Dicom2RunVector

Definition at line 56 of file Dicom2Run.hh.

Constructor & Destructor Documentation

Dicom2Run() [1/2]

Dicom2Run::Dicom2Run

(

)

(Description) Dicom2Run Class is for accumulating scored quantities which is scored using G4MutiFunctionalDetector and G4VPrimitiveScorer.

Accumulation is done using G4THitsVector object.

The constructor Dicom2Run(const std::vector<G4String> mfdName) needs a vector filled with MultiFunctionalDetector names which was assigned at instantiation of MultiFunctionalDetector(MFD). Then Dicom2Run constructor automatically scans primitive scorers in the MFD, and obtains collectionIDs of all collections associated to those primitive scorers. Futhermore, the G4THitsVector objects for accumulating during a RUN are automatically created too. (*) Collection Name is same as primitive scorer name.

The resultant information is kept inside Dicom2Run objects as data members. std::vector<G4String> fCollName; // Collection Name, std::vector<G4int> fCollID; // Collection ID, std::vector<Dicom2RunVector*> fRunMap; // HitsVector for RUN.

The resualtant HitsVector objects are obtain using access method, GetHitsVector(..).

Definition at line 69 of file Dicom2Run.cc.

: DicomRun()
{ }

Dicom2Run() [2/2]

Dicom2Run::Dicom2Run

(

const std::vector< G4String >

mfdName

)

Definition at line 77 of file Dicom2Run.cc.

: DicomRun()
{
    ConstructMFD(mfdName);
}

~Dicom2Run()

Dicom2Run::~Dicom2Run ( )

virtual

Definition at line 87 of file Dicom2Run.cc.

{
    //--- Clear HitsVector for RUN
    for(std::size_t i = 0; i < fRunMap.size(); ++i)
    {
         if(fRunMap[i])
            fRunMap[i]->clear();
    }
    fCollName.clear();
    fCollID.clear();
    fRunMap.clear();
}

Member Function Documentation

RecordEvent()

void Dicom2Run::RecordEvent ( const G4Event *  aEvent )

virtual

Reimplemented from DicomRun.

Definition at line 165 of file Dicom2Run.cc.

{
    DicomRun::RecordEvent(aEvent);
 
    //G4cout << "Dicom Run :: Recording event " << aEvent->GetEventID()
    //<< "..." << G4endl;
    //=============================
    // HitsCollection of This Event
    //============================
    G4HCofThisEvent* HCE = aEvent->GetHCofThisEvent();
    if (!HCE)
        return;
 
    //=======================================================
    // Sum up HitsVector of this Event  into HitsVector of this RUN
    //=======================================================
    for(std::size_t i = 0; i < fCollID.size(); ++i)
    {
        // Loop over HitsCollection
        G4THitsMap<G4double>* EvtMap = nullptr;
        if(fCollID[i] >= 0)
        {
            // Collection is attached to HCE
            EvtMap = static_cast<G4THitsMap<G4double>*>(HCE->GetHC(fCollID[i]));
        }
        else
        {
            G4cout <<" Error EvtMap Not Found "<< i << G4endl;
        }
 
        // if valid pointer, add the pointer
        if(EvtMap)
        {
            //for(auto itr = EvtMap->begin(); itr != EvtMap->end(); ++itr)
            //    G4cout << "adding " << *EvtMap->GetObject(itr) << G4endl;
            //=== Sum up HitsVector of this event to HitsVector of RUN.===
            *fRunMap[i] += *EvtMap;
        }
    }
}

GetNumberOfHitsMap()

size_t Dicom2Run::GetNumberOfHitsMap ( ) const

inline

Definition at line 71 of file Dicom2Run.hh.

{ return fRunMap.size(); }

GetHitsVector() [1/3]

Dicom2RunVector * Dicom2Run::GetHitsVector ( G4int  i ) const

inline

Definition at line 75 of file Dicom2Run.hh.

{return fRunMap[i];}

GetHitsVector() [2/3]

Dicom2Run::Dicom2RunVector * Dicom2Run::GetHitsVector	(	const G4String &	detName,
		const G4String &	colName
	)		const

Definition at line 231 of file Dicom2Run.cc.

{
    G4String fullName = detName+"/"+colName;
    return GetHitsVector(fullName);
}

GetHitsVector() [3/3]

Dicom2Run::Dicom2RunVector * Dicom2Run::GetHitsVector

(

const G4String &

fullName

)

const

Definition at line 243 of file Dicom2Run.cc.

{
 
    std::size_t Ncol = fCollName.size();
    for(std::size_t i = 0; i < Ncol; ++i)
    {
        if(fCollName[i] == fullName)
        {
            return fRunMap[i];
        }
    }
 
    G4Exception("Dicom2Run", fullName.c_str(), JustWarning,
                "GetHitsVector failed to locate the requested HitsVector");
    return nullptr;
}

ConstructMFD()

void Dicom2Run::ConstructMFD

(

const std::vector< G4String > &

mfdName

)

Definition at line 104 of file Dicom2Run.cc.

{
    DicomRun::ConstructMFD(mfdName);
 
    G4SDManager* SDman = G4SDManager::GetSDMpointer();
    //=================================================
    //  Initalize RunMaps for accumulation.
    //  Get CollectionIDs for HitCollections.
    //=================================================
    for(std::size_t idet = 0; idet < mfdName.size(); ++idet)
    {
        // Loop for all MFD.
        G4String detName = mfdName[idet];
        //--- Seek and Obtain MFD objects from SDmanager.
        G4MultiFunctionalDetector* mfd =
                (G4MultiFunctionalDetector*)
                (SDman->FindSensitiveDetector(detName));
        //
        if(mfd)
        {
            //--- Loop over the registered primitive scorers.
            for (G4int icol = 0; icol < mfd->GetNumberOfPrimitives(); ++icol)
            {
                // Get Primitive Scorer object.
                G4VPrimitiveScorer* scorer = mfd->GetPrimitive(icol);
                // collection name and collectionID for HitsCollection,
                // where type of HitsCollection is G4THitsVector in case
                // of primitive scorer.
                // The collection name is given by :
                //  <MFD name>/<Primitive Scorer name>.
                G4String collectionName = scorer->GetName();
                G4String fullCollectionName = detName+"/"+collectionName;
                G4int    collectionID = SDman->GetCollectionID(fullCollectionName);
                //
                if(collectionID >= 0)
                {
                    G4cout << "++ "<<fullCollectionName<< " id " << collectionID
                           << G4endl;
                    // Store obtained HitsCollection information into data
                    // members. qnd creates new G4THitsVector for accumulating
                    // quantities during RUN.
                    fCollName.push_back(fullCollectionName);
                    fCollID.push_back(collectionID);
                    fRunMap.push_back(new Dicom2RunVector(detName,
                                                          collectionName));
                }
                else
                {
                    G4cout << "** collection " << fullCollectionName << " not found. "
                           <<G4endl;
                }
            }
        }
    }
}

Merge()

void Dicom2Run::Merge ( const G4Run *  aRun )

virtual

Reimplemented from DicomRun.

Definition at line 208 of file Dicom2Run.cc.

{
    DicomRun::Merge(aRun);
 
    const Dicom2Run* localRun = static_cast<const Dicom2Run*>(aRun);
 
    Copy(fCollName, localRun->fCollName);
    Copy(fCollID, localRun->fCollID);
    std::size_t ncopies = Copy(fRunMap, localRun->fRunMap);
    // copy function returns the fRunMap size if all data is copied
    // so this loop isn't executed the first time around
    for(std::size_t i = ncopies; i < fRunMap.size(); ++i)
        *fRunMap[i] += *localRun->fRunMap[i];
}

Member Data Documentation

fCollName

std::vector<G4String> Dicom2Run::fCollName

private

Definition at line 86 of file Dicom2Run.hh.

fCollID

std::vector<G4int> Dicom2Run::fCollID

private

Definition at line 87 of file Dicom2Run.hh.

fRunMap

std::vector<Dicom2RunVector*> Dicom2Run::fRunMap

private

Definition at line 88 of file Dicom2Run.hh.

---

The documentation for this class was generated from the following files:

• extended/medical/DICOM2/include/Dicom2Run.hh
• extended/medical/DICOM2/src/Dicom2Run.cc