Inheritance diagram for GIMLI::DCSRMultiElectrodeModelling:

Collaboration diagram for GIMLI::DCSRMultiElectrodeModelling:

Public Member Functions
	DCSRMultiElectrodeModelling (bool verbose=false)

	DCSRMultiElectrodeModelling (Mesh &mesh, bool verbose=false)

	DCSRMultiElectrodeModelling (Mesh &mesh, DataContainerERT &dataContainer, bool verbose=false)

virtual void	calculateK (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB, RMatrix &solutionK, int kIdx)

void	setPrimaryPotFileBody (const std::string &primPotFileBody)

void	setPrimaryPotential (RMatrix &primPot)

RMatrix &	primaryPotential ()

void	setPrimaryMesh (Mesh &mesh)

void	setPrimaryMesh (const std::string &meshname)

Mesh &	primaryMesh ()

virtual void	preCalculate (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB)

Public Member Functions inherited from GIMLI::DCMultiElectrodeModelling
	DCMultiElectrodeModelling (bool verbose=false)

	DCMultiElectrodeModelling (Mesh &mesh, bool verbose=false)

	DCMultiElectrodeModelling (DataContainerERT &dataContainer, bool verbose=false)

	DCMultiElectrodeModelling (Mesh &mesh, DataContainerERT &dataContainer, bool verbose=false)

void	assembleStiffnessMatrixDCFEMByPass (RSparseMatrix &S)

void	assembleStiffnessMatrixDCFEMByPass (CSparseMatrix &S)

virtual void	createJacobian (const RVector &model)

virtual void	createConstraints ()

DataContainerERT &	dataContainer () const

virtual RVector	createDefaultStartModel ()

void	mapERTModel (const CVector &model, Complex background)

void	mapERTModel (const RVector &model, double background)

virtual RVector	response (const RVector &model)

RVector	response (const RVector &model, double background)

void	createCurrentPattern (std::vector< ElectrodeShape * > &eA, std::vector< ElectrodeShape * > &eB, bool reciprocity)

virtual void	calculate (DataMap &dMap)

virtual void	calculate (DataContainerERT &data, bool reciprocity=false)

virtual void	calculate (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB)

virtual void	calculateK (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB, CMatrix &solutionK, int kIdx)

template<class ValueType >
void	calculateKAnalyt (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB, Matrix< ValueType > &solutionK, double k, int kIdx) const

void	setTopography (bool topography)

bool	topography () const

bool	neumann () const

void	setComplex (bool c)

bool	complex () const

void	setDipoleCurrentPattern (bool dipole)

bool	dipoleCurrentPattern () const

void	setAnalytical (bool ana)

bool	analytical () const

void	collectSubPotentials (RMatrix &subSolutions)

const std::map< Index, Index > &	currentPatternIdxMap () const

void	setBypassMapFile (const std::string &fileName)

void	setkValues (const RVector &v)

const RVector &	kValues () const

void	setWeights (const RVector &v)

const RVector &	weights () const

const std::vector< ElectrodeShape * > &	electrodes () const

void	setContactImpedances (const RVector &zi)

virtual RVector	calcGeometricFactor (const DataContainerERT &data, Index nModel=0)

void	setSingValue (bool s=true)

bool	isSetSingValue () const

void	setSolver (SolverWrapper *solver)

Public Member Functions inherited from GIMLI::ModellingBase
	ModellingBase (bool verbose=false)

	ModellingBase (DataContainer &dataContainer, bool verbose=false)

	ModellingBase (const Mesh &mesh, bool verbose=false)

	ModellingBase (const Mesh &mesh, DataContainer &dataContainer, bool verbose=false)

void	setVerbose (bool verbose)

bool	verbose () const

virtual RVector	response_mt (const RVector &model, Index i=0) const

RVector	operator() (const RVector &model)

void	setData (DataContainer &data)

DataContainer &	data () const

virtual RVector	startModel ()

virtual void	setStartModel (const RVector &startModel)

void	setMesh (const Mesh &mesh, bool ignoreRegionManager=false)

Mesh *	mesh ()

void	createRefinedForwardMesh (bool refine=true, bool pRefine=false)

void	deleteMesh ()

virtual void	setJacobian (MatrixBase *J)

virtual void	createJacobian (const RVector &model, const RVector &resp)

virtual void	createJacobian_mt (const RVector &model, const RVector &resp)

virtual void	initJacobian ()

MatrixBase *	jacobian ()

MatrixBase *	jacobian () const

virtual RMatrix &	jacobianRef () const

virtual RMatrix &	jacobianRef ()

virtual void	clearJacobian ()

RVector	createMappedModel (const RVector &model, double background=-9e99) const

void	setRegionManager (RegionManager *reg)

const RegionManager &	regionManager () const

RegionManager &	regionManager ()

RegionManager &	regionManagerRef ()

bool	verbose ()

Region *	region (int marker)

RVector	createStartModel ()

RVector	createStartVector ()

void	initRegionManager ()

void	setThreadCount (Index nThreads)

Index	threadCount ()

void	setMultiThreadJacobian (Index nThreads)

Index	multiThreadJacobian () const

Protected Member Functions
virtual void	updateMeshDependency_ ()

virtual void	updateDataDependency_ ()

void	checkPrimpotentials_ (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB)

Protected Member Functions inherited from GIMLI::DCMultiElectrodeModelling
template<class ValueType >
void	calculateK_ (const std::vector< ElectrodeShape * > &eA, const std::vector< ElectrodeShape * > &eB, Matrix< ValueType > &solutionK, int kIdx)

template<class ValueType >
void	assembleStiffnessMatrixDCFEMByPass_ (SparseMatrix< ValueType > &S)

template<class ValueType >
DataMap	response_ (const Vector< ValueType > &model, ValueType background)

template<class ValueType >
Matrix< ValueType > *	prepareJacobianT_ (const Vector< ValueType > &model)

RMatrix *	prepareJacobian_ (const RVector &model)

CMatrix *	prepareJacobian_ (const CVector &model)

void	createJacobian_ (const RVector &model, const RMatrix &u, RMatrix *J)

void	createJacobian_ (const CVector &model, const CMatrix &u, CMatrix *J)

virtual void	deleteMeshDependency_ ()

virtual void	searchElectrodes_ ()

Protected Member Functions inherited from GIMLI::ModellingBase
void	setMesh_ (const Mesh &mesh, bool update=true)

Protected Attributes
std::string	primPotFileBody_

bool	primPotOwner_

RMatrix *	primPot_

bool	primMeshOwner_

Mesh *	primMesh_

Mesh	mesh1_

Protected Attributes inherited from GIMLI::DCMultiElectrodeModelling
MatrixBase *	subSolutions_

bool	complex_

bool	JIsRMatrix_

bool	JIsCMatrix_

bool	analytical_

bool	topography_

bool	neumannDomain_

bool	subpotOwner_

bool	lastIsReferenz_

bool	setSingValue_

std::string	byPassFile_

RVector	kValues_

RVector	weights_

double	surfaceZ_

IndexArray	calibrationSourceIdx_

IndexArray	bypassNodeIdx_

std::vector< ElectrodeShape * >	electrodes_

ElectrodeShape *	electrodeRef_

std::vector< ElectrodeShape * >	passiveCEM_

RVector3	sourceCenterPos_

bool	buildCompleteElectrodeModel_

bool	dipoleCurrentPattern_

std::map< Index, Index >	currentPatternIdxMap_

RMatrix	potentialsCEM_

RVector	vContactImpedance_

DataMap *	primDataMap_

SolverWrapper *	solver_

Protected Attributes inherited from GIMLI::ModellingBase
Mesh *	mesh_

DataContainer *	dataContainer_

MatrixBase *	jacobian_

bool	ownJacobian_

MatrixBase *	constraints_

bool	ownConstraints_

RMatrix	solutions_

RVector	startModel_

bool	verbose_

bool	regionManagerInUse_

bool	ownRegionManager_

Index	nThreads_

Index	nThreadsJacobian_

Member Function Documentation

◆ checkPrimpotentials_()

void GIMLI::DCSRMultiElectrodeModelling::checkPrimpotentials_	(	const std::vector< ElectrodeShape * > &	eA,
		const std::vector< ElectrodeShape * > &	eB
	)

protected

First check if primPot can be recovered by loading binary matrix

check for sizes here!!!

no binary matrix so calculate if topography present and no alternativ filename given

First check ready!

now check if all necessary primary potentials loaded or calculated (topography). On demand load from single file or calculate analytically

** primary potential vector is unknown

** primary potential file body is NOT_DEFINED so we try to determine ourself

** primary potential file body is given so we load it

** load 3D potential

else load 2d pot

else load pot

if primPot[potID] == 0

for each currentPattern

References GIMLI::DCMultiElectrodeModelling::calculate(), GIMLI::Mesh::createP2(), GIMLI::Stopwatch::duration(), GIMLI::interpolate(), GIMLI::load(), GIMLI::ModellingBase::setMesh(), and GIMLI::Mesh::showInfos().

◆ preCalculate()

void GIMLI::DCSRMultiElectrodeModelling::preCalculate	(	const std::vector< ElectrodeShape * > &	eA,
		const std::vector< ElectrodeShape * > &	eB
	)

virtual

check for valid primary potentials, calculate analytical or numerical if nessecary

Reimplemented from GIMLI::DCMultiElectrodeModelling.

Public Member Functions

Protected Member Functions

Protected Attributes

Member Function Documentation

◆ checkPrimpotentials_()

◆ preCalculate()