RE06Run Class Reference

#include <Doxymodules_runAndEvent.h>

Inheritance diagram for RE06Run:

Public Member Functions
	RE06Run ()
virtual	~RE06Run ()
virtual void	RecordEvent (const G4Event *)
virtual void	Merge (const G4Run *)
G4double	GetTotalE (G4int i) const
G4double	GetNGamma (G4int i) const
G4double	GetNElectron (G4int i) const
G4double	GetNPositron (G4int i) const
G4double	GetTotalL (G4int i) const
G4double	GetNStep (G4int i) const
G4double	GetEMinGamma (G4int i) const
G4double	GetEMinElectron (G4int i) const
G4double	GetEMinPositron (G4int i) const
G4double	GetParaValue (G4int i, G4int j, G4int k) const

Private Member Functions
G4double	GetTotal (const G4THitsMap< G4double > &map) const
G4double	FindMinimum (const G4THitsMap< G4double > &map) const

Private Attributes
G4THitsMap< G4double >	fMapSum [6][6]
G4int	fColIDSum [6][6]
G4THitsMap< G4double >	fMapMin [6][3]
G4int	fColIDMin [6][3]
G4THitsMap< G4double >	fMapPara [3][6]
G4int	fColIDPara [3][6]

Detailed Description

Definition at line 142 of file Doxymodules_runAndEvent.h.

Constructor & Destructor Documentation

RE06Run()

RE06Run::RE06Run

(

)

Definition at line 38 of file RE06Run.cc.

 : G4Run()
{
  G4String detName[6] 
    = {"Calor-A_abs","Calor-A_gap",
       "Calor-B_abs","Calor-B_gap",
       "Calor-C_abs","Calor-C_gap"};
       
  G4String primNameSum[6] 
    = {"eDep","nGamma","nElectron","nPositron","trackLength","nStep"};
    
  G4String primNameMin[3] 
    = {"minEkinGamma","minEkinElectron","minEkinPositron"};
 
  G4String paraName[3] 
    = {"Calor-AP_para","Calor-BP_para","Calor-CP_para"};
 
  G4SDManager* SDMan = G4SDManager::GetSDMpointer();
  G4String fullName;
  size_t i,j;
  for(i=0;i<6;i++)
  {
    for(j=0;j<6;j++)
    {
      fullName = detName[i]+"/"+primNameSum[j];
      fColIDSum[i][j] = SDMan->GetCollectionID(fullName);
    }
    for(j=0;j<3;j++)
    {
      fullName = detName[i]+"/"+primNameMin[j];
      fColIDMin[i][j] = SDMan->GetCollectionID(fullName);
    }
  }
  for(i=0;i<3;i++)
  {
    for(j=0;j<6;j++)
    {
      fullName = paraName[i]+"/"+primNameSum[j];
      fColIDPara[i][j] = SDMan->GetCollectionID(fullName);
    }
  }
  
}

~RE06Run()

RE06Run::~RE06Run ( )

virtual

Definition at line 84 of file RE06Run.cc.

{;}

Member Function Documentation

RecordEvent()

void RE06Run::RecordEvent ( const G4Event *  evt )

virtual

Definition at line 89 of file RE06Run.cc.

{
  G4HCofThisEvent* HCE = evt->GetHCofThisEvent();
  if(!HCE) return;
  numberOfEvent++;
  size_t i,j;
  for(i=0;i<6;i++)
  {
    for(j=0;j<6;j++)
    {
      G4THitsMap<G4double>* evtMap 
        = (G4THitsMap<G4double>*)(HCE->GetHC(fColIDSum[i][j]));
      fMapSum[i][j] += *evtMap;
    }
 
    for(j=0;j<3;j++)
    {
      G4THitsMap<G4double>* evtMap 
        = (G4THitsMap<G4double>*)(HCE->GetHC(fColIDMin[i][j]));
      std::map<G4int,G4double*>::iterator itr = evtMap->GetMap()->begin();
      for(; itr != evtMap->GetMap()->end(); itr++)
      {
        G4int key = (itr->first);
        G4double val = *(itr->second);
        G4double* mapP = fMapMin[i][j][key];
        if( mapP && (val>*mapP) ) continue;
        fMapMin[i][j].set(key,val);
      }
    }
 
  }
  for(i=0;i<3;i++)
  {
    for(j=0;j<6;j++)
    {
      G4THitsMap<G4double>* evtMap 
        = (G4THitsMap<G4double>*)(HCE->GetHC(fColIDPara[i][j]));
      fMapPara[i][j] += *evtMap;
    }
  }
}

Merge()

void RE06Run::Merge ( const G4Run *  aRun )

virtual

Definition at line 132 of file RE06Run.cc.

                                      {
  const RE06Run * localRun = static_cast<const RE06Run *>(aRun);
  
  for(G4int i = 0; i < 6; i++) {
    for(G4int j = 0; j < 6; j++) {
      fMapSum[i][j] += localRun->fMapSum[i][j];
    }
 
    for(G4int j = 0; j < 3; j++) {
      std::map<G4int, G4double*>::iterator itr = localRun->fMapMin[i][j].GetMap()->begin();
      for(; itr != localRun->fMapMin[i][j].GetMap()->end(); itr++) {
        G4int key = itr->first;
        G4double val = *(itr->second);
        G4double * mapP = fMapMin[i][j][key];
        if(!mapP || val < *mapP) fMapMin[i][j].set(key, val);
      }
    }
  }
 
  for(G4int i = 0; i < 3; i++) {
      for(G4int j = 0; j < 6; j++) {
        fMapPara[i][j] += localRun->fMapPara[i][j];
      }
  }
  
  G4Run::Merge(aRun);
}

GetTotalE()

G4double RE06Run::GetTotalE ( G4int  i ) const

inline

Definition at line 50 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][0]); }

GetNGamma()

G4double RE06Run::GetNGamma ( G4int  i ) const

inline

Definition at line 51 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][1]); }

GetNElectron()

G4double RE06Run::GetNElectron ( G4int  i ) const

inline

Definition at line 52 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][2]); }

GetNPositron()

G4double RE06Run::GetNPositron ( G4int  i ) const

inline

Definition at line 53 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][3]); }

GetTotalL()

G4double RE06Run::GetTotalL ( G4int  i ) const

inline

Definition at line 54 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][4]); }

GetNStep()

G4double RE06Run::GetNStep ( G4int  i ) const

inline

Definition at line 55 of file RE06Run.hh.

{ return GetTotal(fMapSum[i][5]); }

GetEMinGamma()

G4double RE06Run::GetEMinGamma ( G4int  i ) const

inline

Definition at line 57 of file RE06Run.hh.

{ return FindMinimum(fMapMin[i][0]);}

GetEMinElectron()

G4double RE06Run::GetEMinElectron ( G4int  i ) const

inline

Definition at line 58 of file RE06Run.hh.

{ return FindMinimum(fMapMin[i][1]);}

GetEMinPositron()

G4double RE06Run::GetEMinPositron ( G4int  i ) const

inline

Definition at line 59 of file RE06Run.hh.

{ return FindMinimum(fMapMin[i][2]);}

GetParaValue()

G4double RE06Run::GetParaValue ( G4int  i, G4int  j, G4int  k  ) const

inline

Definition at line 61 of file RE06Run.hh.

  {
    G4double* p = fMapPara[i][j][k];
    if(p) return *p;
    return 0.;
  }

GetTotal()

G4double RE06Run::GetTotal ( const G4THitsMap< G4double > &  map ) const

private

Definition at line 161 of file RE06Run.cc.

{
  G4double tot = 0.;
  if(map.GetSize()==0) return tot;
  std::map<G4int,G4double*>::iterator itr = map.GetMap()->begin();
  for(; itr != map.GetMap()->end(); itr++) 
  { tot += *(itr->second); }
  return tot;
}

FindMinimum()

G4double RE06Run::FindMinimum ( const G4THitsMap< G4double > &  map ) const

private

Definition at line 173 of file RE06Run.cc.

{
  G4double val = DBL_MAX;
 
  if(map.GetSize()==0) return val;
  std::map<G4int,G4double*>::iterator itr = map.GetMap()->begin();
  for(; itr != map.GetMap()->end(); itr++) 
  { if(val>*(itr->second)) val = *(itr->second); }
  return val;
}

Member Data Documentation

fMapSum

G4THitsMap<G4double> RE06Run::fMapSum[6][6]

private

Definition at line 80 of file RE06Run.hh.

fColIDSum

G4int RE06Run::fColIDSum[6][6]

private

Definition at line 81 of file RE06Run.hh.

fMapMin

G4THitsMap<G4double> RE06Run::fMapMin[6][3]

private

Definition at line 90 of file RE06Run.hh.

fColIDMin

G4int RE06Run::fColIDMin[6][3]

private

Definition at line 91 of file RE06Run.hh.

fMapPara

G4THitsMap<G4double> RE06Run::fMapPara[3][6]

private

Definition at line 101 of file RE06Run.hh.

fColIDPara

G4int RE06Run::fColIDPara[3][6]

private

Definition at line 102 of file RE06Run.hh.

---

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

• .doxygen/Doxymodules_runAndEvent.h
• extended/runAndEvent/RE06/include/RE06Run.hh
• extended/runAndEvent/RE06/src/RE06Run.cc