G4ITModelHandler Class Reference

#include <G4ITModelHandler.hh>

Public Member Functions
	G4ITModelHandler ()
	G4ITModelHandler (const G4ITModelHandler &other)
G4ITModelHandler &	operator= (const G4ITModelHandler &rhs)
	~G4ITModelHandler ()
void	Initialize ()
void	RegisterModel (G4VITStepModel *aModel, const G4double globalTime)
G4ITModelManager *	GetModelManager (G4ITType, G4ITType)
void	SetModel (G4ITType, G4ITType, G4VITStepModel *aModel, G4double startingTime)
G4VITStepModel *	GetModel (G4ITType, G4ITType, const G4double globalTime)
const std::vector< std::vector < G4ITModelManager * > > *	GetAllModelManager ()
bool	GetTimeStepComputerFlag ()
bool	GetReactionProcessFlag ()

Protected Attributes
G4bool	fIsInitialized
std::vector< std::vector < G4ITModelManager * > >	fModelManager
G4bool	fTimeStepComputerFlag
G4bool	fReactionProcessFlag

Detailed Description

G4ITModelHandler holds for two IT types the corresponding model manager

Definition at line 57 of file G4ITModelHandler.hh.

Constructor & Destructor Documentation

G4ITModelHandler::G4ITModelHandler

(

)

Definition at line 39 of file G4ITModelHandler.cc.

{
  //ctor
  fIsInitialized = false;
  fTimeStepComputerFlag = false;
  fReactionProcessFlag = false;

  size_t IT_size(G4ITType::size());

  fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
  for (G4int i = 0; i < (int) IT_size; i++)
  {
    fModelManager[i].assign(IT_size, 0);
  }
}

Here is the call graph for this function:

G4ITModelHandler::G4ITModelHandler

(

const G4ITModelHandler &

other

)

Definition at line 75 of file G4ITModelHandler.cc.

{
  //copy ctor
  size_t IT_size(G4ITType::size());

  fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());
  for (int i = 0; i < (int) IT_size; i++)
  {
    fModelManager[i].assign(IT_size, 0);
    for (int j = 0; j < (int) IT_size; j++)
    {
      if (other.fModelManager[i][j] != 0)
      {
        fModelManager[i][j] = new G4ITModelManager(
            *(other.fModelManager[i][j]));
      }
    }
  }

  fIsInitialized = other.fIsInitialized;
  fTimeStepComputerFlag = other.fTimeStepComputerFlag;
  fReactionProcessFlag = other.fReactionProcessFlag;
}

Here is the call graph for this function:

G4ITModelHandler::~G4ITModelHandler

(

)

Default destructor

Definition at line 55 of file G4ITModelHandler.cc.

{
  //dtor
  G4int size = fModelManager.size();

  for (G4int i = 0; i < size; i++)
  {
    for (G4int j = 0; j <= i; j++)
    {
      if (fModelManager[i][j])
      {
        delete fModelManager[i][j];
        fModelManager[i][j] = 0;
        fModelManager[j][i] = 0;
      }
    }
  }
  fModelManager.clear();
}

Member Function Documentation

const std::vector<std::vector<G4ITModelManager*> >* G4ITModelHandler::GetAllModelManager ( )

inline

Definition at line 84 of file G4ITModelHandler.hh.

  {
    return &fModelManager;
  }

G4VITStepModel * G4ITModelHandler::GetModel	(	G4ITType	type1,
		G4ITType	type2,
		const G4double	globalTime
	)

Definition at line 203 of file G4ITModelHandler.cc.

{
  if (fModelManager.empty())
  {
    return 0;
  }

  if ((int) fModelManager.size() < type1) return 0;

  std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));

  if ((int) v->size() < type2) return 0;

  if (v->at(type2))
  {
    return v->at(type2)->GetModel(globalTime);
  }
  return 0;
}

G4ITModelManager * G4ITModelHandler::GetModelManager ( G4ITType  type1, G4ITType  type2  )

inline

Definition at line 106 of file G4ITModelHandler.hh.

{
  if (fModelManager.empty())
  {
    return 0;
  }

  if ((int) fModelManager.size() < type1) return 0;

  std::vector<G4ITModelManager*>* v = &(fModelManager.at(type1));

  if ((int) v->size() < type2) return 0;

  return v->at(type2);
}

bool G4ITModelHandler::GetReactionProcessFlag ( )

inline

Definition at line 93 of file G4ITModelHandler.hh.

  {
    return fReactionProcessFlag;
  }

bool G4ITModelHandler::GetTimeStepComputerFlag ( )

inline

Definition at line 89 of file G4ITModelHandler.hh.

  {
    return fTimeStepComputerFlag;
  }

void G4ITModelHandler::Initialize

(

)

Definition at line 106 of file G4ITModelHandler.cc.

{
  fIsInitialized = true;

  for (G4int i = 0; i < int(fModelManager.size()); i++)
  {
    for (G4int j = 0; j <= i; j++)
    {
      G4ITModelManager* modman = fModelManager[i][j];
      if (modman)
      {
        modman->Initialize();
      }
    }
  }
}

Here is the call graph for this function:

G4ITModelHandler & G4ITModelHandler::operator=

(

const G4ITModelHandler &

rhs

)

Definition at line 99 of file G4ITModelHandler.cc.

{
  if (this == &rhs) return *this; // handle self assignment
  //assignment operator
  return *this;
}

void G4ITModelHandler::RegisterModel	(	G4VITStepModel *	aModel,
		const G4double	globalTime
	)

Definition at line 123 of file G4ITModelHandler.cc.

{
  assert(aModel != 0);

  //________________________________________________
  // Prepare the correct model manager
  if (fModelManager.empty())
  {
    size_t IT_size(G4ITType::size());
    fModelManager.assign(IT_size, std::vector<G4ITModelManager*>());

    for (int i = 0; i < (int) IT_size; i++)
    {
      fModelManager[i].assign((size_t) i, 0);
    }
  }

  G4ITType type1;
  G4ITType type2;

  //________________________________________________
  // Retrieve applicability
  aModel->IsApplicable(type1, type2);

  if (type1 > type2)
  {
    G4ITType buffer(-1);
    buffer = type1;
    type1 = type2;
    type2 = buffer;
  }

  if (fModelManager[type1][type2] == 0)
  {
    fModelManager[type1][type2] = new G4ITModelManager();
  }

  fModelManager[type1][type2]->SetModel(aModel, startingTime);

  //________________________________________________
  // Setup ITStepManager
  if (aModel->GetTimeStepper())
  {
    fTimeStepComputerFlag = true;
  }
  if (aModel->GetReactionProcess())
  {
    fReactionProcessFlag = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ITModelHandler::SetModel	(	G4ITType	type1,
		G4ITType	type2,
		G4VITStepModel *	aModel,
		G4double	startingTime
	)

Definition at line 175 of file G4ITModelHandler.cc.

{
  assert(aModel == 0);

  if (type1 > type2)
  {
    G4ITType buffer(-1);
    buffer = type1;
    type1 = type2;
    type2 = buffer;
  }

  if (type1 > (int) fModelManager.capacity())
  {
    fModelManager.reserve(type1);
  }

  if (type2 > (int) fModelManager[type1].capacity())
  {
    fModelManager[type1].reserve(type2);
  }

  fModelManager[type1][type2]->SetModel(aModel, startingTime);
}

Member Data Documentation

G4bool G4ITModelHandler::fIsInitialized

protected

Definition at line 99 of file G4ITModelHandler.hh.

std::vector<std::vector<G4ITModelManager*> > G4ITModelHandler::fModelManager

protected

Definition at line 100 of file G4ITModelHandler.hh.

G4bool G4ITModelHandler::fReactionProcessFlag

protected

Definition at line 103 of file G4ITModelHandler.hh.

G4bool G4ITModelHandler::fTimeStepComputerFlag

protected

Definition at line 102 of file G4ITModelHandler.hh.

---

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

• geant4.10.03.p01/source/processes/electromagnetic/dna/management/include/G4ITModelHandler.hh
• geant4.10.03.p01/source/processes/electromagnetic/dna/management/src/G4ITModelHandler.cc