DinverCore::ModelRepository Class Reference

Brief description of class still missing. More...

#include <ModelRepository.h>

List of all members.

Public Member Functions
int	activeModelCount () const
void	addModel (NewModel *m)
void	addReport (NewModel *m, AbstractForward *forward)
ModelSet *	allModels ()
int	bestModelCount () const
int	bestModelIndex () const
uint	checksum () const
void	clear ()
ParentIndex *	createModel (double randomValue, RealSpace &parameterSpace) const
int	expectedModelCount () const
AbstractForward *	forward ()
const AbstractForward *	forward () const
int	giveUpCount () const
bool	importModels (QString fileName, bool strict=true)
void	init ()
void	lock () const
double	misfit (int modelIndex) const
const int *	model (int modelIndex) const
	ModelRepository ()
bool	openReport (const QString &fileName)
bool	operator== (const ModelRepository &o) const
void	printActiveModels ()
int	rejectedCount () const
void	setBestModelCount (int nr)
void	setForward (AbstractForward *f)
void	setGiveUp (double gu)
void	setMaximumBestModelCount (int n)
void	setMaximumModelCount (int n)
void	setMaximumQueueLength (int l)
void	setMaximumSavedMisfit (double m)
void	setStorage ()
void	setWalkCount (int n)
bool	start (int nThreads, Generator::Type type)
void	stop ()
void	unlock () const
int	validModelCount () const
const Parameter *	variableParameter (int paramIndex) const
int	variableParameterCount () const
double	variableParameterValue (int modelIndex, int paramIndex) const
int	visitedModelCount () const
void	wait ()
	~ModelRepository ()

---

Detailed Description

Brief description of class still missing.

Full description of class still missing

---

Constructor & Destructor Documentation

DinverCore::ModelRepository::ModelRepository

(

)

Description of constructor still missing

References TRACE.

    : _terminated(false)
  {
    TRACE;

    _maximumModelCount=10000;
    _maximumBestModelCount=RAND_MAX;  // by default no limit
    _maximumQueueLenght=50;           // A similar job as ns=50 in old releases
    _maximumSavedMisfit=1e99;         // by default no limit
    _giveUp=0.9;
    _walkCount=2;

    _processingQueue=false;
    _report=0;
    _forward=0;
    _parameterSpaceChecksum=0;
    _allModels=0;
    _generatorModels=0;
  }

DinverCore::ModelRepository::~ModelRepository

(

)

Description of destructor still missing

References QGpCoreTools::SharedObject::removeReference(), TRACE, and wait().

  {
    TRACE;
    wait();
    // Not owner of forward
    delete _allModels;
    if(_generatorModels) {
      GeneratorModels::removeReference(_generatorModels);
    }
    delete _report;
  }

---

Member Function Documentation

int DinverCore::ModelRepository::activeModelCount

(

)

const

References DinverCore::GeneratorModels::activeModels(), and DinverCore::ActiveModels::count().

Referenced by InversionThread::activeModelCount().

  {
    return _generatorModels->activeModels()->count();
  }

void DinverCore::ModelRepository::addModel

(

NewModel *

m

)

Called by all ModelGenerator after creating one new model. Thread-safe.

References TRACE.

  {
    TRACE;
    _queueLock.lock();
    _newModels.enqueue(m);
    if(!_processingQueue && _newModels.count()>=_maximumQueueLenght) {
      processQueue();
    }
    _queueLock.unlock();
  }

void DinverCore::ModelRepository::addReport	(	NewModel *	m,
		AbstractForward *	forward
	)

References DinverCore::ReportWriter::addModel(), DinverCore::NewModel::isValidMisfit(), DinverCore::NewModel::isValidParent(), DinverCore::NewModel::misfit(), DinverCore::AbstractForward::parameterSpace(), TRACE, and DinverCore::AbstractForward::writeReport().

  {
    TRACE;
    if(_report &&
       m->isValidParent() &&
       m->isValidMisfit() &&
       m->misfit()<=_maximumSavedMisfit) {
      _reportLock.lock();
      _report->addModel(m->misfit(), _parameterSpaceChecksum, forward->parameterSpace());
      forward->writeReport(_report);
      _reportLock.unlock();
    }
  }

ModelSet* DinverCore::ModelRepository::allModels

(

)

[inline]

{return _allModels;}

int DinverCore::ModelRepository::bestModelCount

(

)

const

References DinverCore::GeneratorModels::bestModels(), and DinverCore::BestModels::count().

Referenced by InversionThread::bestModelCount().

  {
    return _generatorModels->bestModels()->count();
  }

int DinverCore::ModelRepository::bestModelIndex

(

)

const

References DinverCore::ModelSet::bestModel().

Referenced by createModel(), and InversionThread::run().

  {
    // TODO: multi-dimensional misfit
    return _allModels->bestModel();
  }

uint DinverCore::ModelRepository::checksum

(

)

const [inline]

Referenced by InversionThread::start(), and InversionThread::xml_writeProperties().

{return _parameterSpaceChecksum;}

void DinverCore::ModelRepository::clear

(

)

References DinverCore::ModelSet::clear(), DinverCore::GeneratorModels::clear(), and TRACE.

Referenced by InversionThread::clear(), and InversionThread::run().

  {
    TRACE;
    _allModels->clear();
    _generatorModels->clear();
  }

ParentIndex * DinverCore::ModelRepository::createModel	(	double	randomValue,
		RealSpace &	parameterSpace
	)		const

Called by all Generator before creating one new model. Thread-safe.

randomValue must be between 0 and 1, generated by Random::ran2().

Returns a ParentIndex ready to model generation. parameterSpace is populated with the values of the selected parent model.

References DinverCore::ParentIndex::activeIndex(), DinverCore::ParentIndex::activeModels(), bestModelIndex(), DinverCore::GeneratorModels::bestModels(), DinverCore::BestModels::count(), DinverCore::ModelSet::lock(), DinverCore::ActiveModels::model(), DinverCore::BestModels::modelIndex(), DinverCore::Parameter::setGridValue(), TRACE, DinverCore::ModelSet::unlock(), DinverCore::RealSpace::variableParameter(), and DinverCore::RealSpace::variableParameterCount().

  {
    TRACE;
    int ndVar=parameterSpace.variableParameterCount();
    // Selects randomly one of the best cells
    _generatorModelLock.lockForRead();
    const BestModels * bestModels=_generatorModels->bestModels();
    int bestModelIndex=(int)round((bestModels->count()-1)*randomValue);
    ParentIndex * parentIndex=new ParentIndex(_generatorModels,
                                  bestModels->modelIndex(bestModelIndex));
    // Copy model to parameter structure to enable condition testing
    _allModels->lock();
    const int * v=parentIndex->activeModels()->model(parentIndex->activeIndex());
    for(int ip=0; ip<ndVar; ip++) {
      parameterSpace.variableParameter(ip)->setGridValue(v[ip]);
    }
    _allModels->unlock();
    _generatorModelLock.unlock();
    return parentIndex;
  }

int DinverCore::ModelRepository::expectedModelCount

(

)

const [inline]

Referenced by InversionThread::expectedModelCount(), and InversionThread::start().

{return _maximumModelCount;}

AbstractForward* DinverCore::ModelRepository::forward

(

)

[inline]

Referenced by InversionThread::forward(), InversionThread::xml_member(), InversionThread::xml_polish(), InversionThread::xml_setProperty(), InversionThread::xml_writeChildren(), InversionThread::xml_writeProperties(), and InversionThread::~InversionThread().

{return _forward;}

const AbstractForward* DinverCore::ModelRepository::forward

(

)

const [inline]

{return _forward;}

int DinverCore::ModelRepository::giveUpCount

(

)

const

References DinverCore::GeneratorModels::giveUpCount().

Referenced by InversionThread::giveUpCount().

  {
    return _generatorModels->giveUpCount();
  }

bool DinverCore::ModelRepository::importModels	(	QString	fileName,
		bool	strict = true
	)

References DinverCore::GeneratorModels::add(), DinverCore::ModelSet::count(), QGpCoreTools::endl(), fileName, DinverCore::ModelSet::importModelsFromAscii(), DinverCore::ModelSet::importModelsFromReport(), DinverCore::ReportReader::isReportFormat(), DinverCore::ReportReader::nModels(), DinverCore::ReportReader::open(), DinverCore::AbstractForward::parameterSpace(), DinverCore::ReportReader::synchronize(), QGpCoreTools::tr(), and TRACE.

Referenced by InversionThread::checkImportModels(), InversionThread::importModels(), DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::run().

  {
    TRACE;
    int i=_allModels->count();

    if(ReportReader::isReportFormat(fileName)) {
      ReportReader report(fileName);
      if(!report.open()) {
        App::stream() << tr("Error opening report %1").arg(fileName) << endl;
        return false;
      }
      report.synchronize();
      _maximumModelCount=report.nModels();

      if(!_allModels->importModelsFromReport(_forward->parameterSpace(), report, strict)) {
        return false;
      }
    } else {
      if(!_allModels->importModelsFromAscii(_forward->parameterSpace(), fileName)) {
        return false;
      }
    }
    int n=_allModels->count();
    for(;i<n;i++) {
      _generatorModels->add(i);
    }
    return true;
  }

void DinverCore::ModelRepository::init

(

)

References QGpCoreTools::AtomicBoolean::setValue(), and TRACE.

Referenced by InversionThread::start().

  {
    TRACE;
    _terminated.setValue(false);
  }

void DinverCore::ModelRepository::lock

(

)

const

Used only by external objects to acces generated models (read only)

References DinverCore::ModelSet::lock().

Referenced by InversionThread::lock().

  {
    if(_allModels) {
      _allModels->lock();
    }
    _generatorModelLock.lockForRead();
  }

double DinverCore::ModelRepository::misfit

(

int

modelIndex

)

const

References DinverCore::ModelSet::misfit().

Referenced by InversionThread::misfit(), and InversionThread::run().

  {
    // TODO: multi-dimensional misfit
    return _allModels ? _allModels->misfit(modelIndex)[0] : 0;
  }

const int * DinverCore::ModelRepository::model

(

int

modelIndex

)

const

References DinverCore::ModelSet::model().

Referenced by start().

  {
    return _allModels->model(modelIndex);
  }

bool DinverCore::ModelRepository::openReport

(

const QString &

fileName

)

Initializes report.

References QGpCoreTools::endl(), DinverCore::ReportWriter::open(), QGpCoreTools::tr(), and TRACE.

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::run().

  {
    TRACE;
    if(!fileName.isEmpty()) {
      delete _report;
      _report=new ReportWriter(fileName);
      if(!_report->open()) {
        App::stream() << tr("Cannot open report %1 for writing").arg(fileName) << endl;
        delete _report;
        _report=0;
        return false;
      }
    }
    return true;
  }

bool DinverCore::ModelRepository::operator==

(

const ModelRepository &

o

)

const

Returns true if the two repositories have the same parameterization.

References DinverCore::AbstractForward::parameterSpace().

  {
    return _forward->parameterSpace()==o._forward->parameterSpace();
  }

void DinverCore::ModelRepository::printActiveModels

(

)

References DinverCore::GeneratorModels::activeModels(), DinverCore::ActiveModels::at(), DinverCore::ActiveModels::count(), QGpCoreTools::endl(), DinverCore::ActiveModel::navigatorHit(), and QGpCoreTools::tr().

Referenced by DinverCore::BatchRun::neighborhoodOptimization().

  {
    const ActiveModels * m=_generatorModels->activeModels();
    for(int i=0; i<m->count(); i++) {
      App::stream() << tr("navigator hit %1 %2").arg(i).arg(m->at(i).navigatorHit()) << endl;
    }
  }

int DinverCore::ModelRepository::rejectedCount

(

)

const

References DinverCore::GeneratorModels::rejectedCount().

Referenced by InversionThread::rejectedCount().

  {
    return _generatorModels->rejectedCount();
  }

void DinverCore::ModelRepository::setBestModelCount

(

int

nr

)

References DinverCore::GeneratorModels::setBestModelCount(), and TRACE.

Referenced by InversionThread::run().

  {
    TRACE;
    _generatorModels->setBestModelCount(nr);
  }

void DinverCore::ModelRepository::setForward

(

AbstractForward *

f

)

Sets forward solver. Ownership is not taken over this forward.

References TRACE.

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::setForward().

  {
    TRACE;
    _forward=f;
  }

void DinverCore::ModelRepository::setGiveUp

(

double

gu

)

[inline]

Referenced by InversionThread::run().

{_giveUp=gu;}

void DinverCore::ModelRepository::setMaximumBestModelCount

(

int

n

)

[inline]

Referenced by DinverCore::BatchRun::neighborhoodOptimization().

{_maximumBestModelCount=n;}

void DinverCore::ModelRepository::setMaximumModelCount

(

int

n

)

[inline]

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::run().

{_maximumModelCount=n;}

void DinverCore::ModelRepository::setMaximumQueueLength

(

int

l

)

[inline]

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::run().

{_maximumQueueLenght=l;}

void DinverCore::ModelRepository::setMaximumSavedMisfit

(

double

m

)

[inline]

Referenced by DinverCore::BatchRun::neighborhoodOptimization().

{_maximumSavedMisfit=m;}

void DinverCore::ModelRepository::setStorage

(

)

References QGpCoreTools::SharedObject::addReference(), DinverCore::RealSpace::checksum(), DinverCore::AbstractForward::parameterSpace(), QGpCoreTools::SharedObject::removeReference(), and DinverCore::RealSpace::variableParameterCount().

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), InversionThread::setStorage(), and InversionThread::xml_polish().

  {
    if(_allModels) {
      ASSERT(_generatorModels);
      delete _allModels;
      GeneratorModels::removeReference(_generatorModels);
    }
    _parameterSpaceChecksum=_forward->parameterSpace().checksum();
    int ndVar=_forward->parameterSpace().variableParameterCount();
    _allModels=new ModelSet(ndVar, 1);
    _generatorModels=new GeneratorModels(_allModels);
    _generatorModels->addReference();
  }

void DinverCore::ModelRepository::setWalkCount

(

int

n

)

[inline]

Referenced by InversionThread::run().

{_walkCount=n;}

bool DinverCore::ModelRepository::start	(	int	nThreads,
		Generator::Type	type
	)

References DinverCore::GeneratorModels::activeModels(), DinverCore::RealSpace::adjustRanges(), DinverCore::GeneratorModels::bestModels(), DinverCore::AbstractForward::clone(), DinverCore::AbstractForward::copyValues(), DinverCore::ActiveModels::count(), DinverCore::BestModels::count(), QGpCoreTools::endl(), DinverCore::AbstractForward::firstModel(), DinverCore::RealSpace::isOkDebug(), DinverCore::AbstractForward::maximumThreadCount(), DinverCore::BestModels::model(), model(), DinverCore::AbstractForward::parameterSpace(), DinverCore::Parameter::setGridValue(), DinverCore::Generator::setType(), DinverCore::RealSpace::setVariableParameters(), DinverCore::Generator::setWalkCount(), QGpCoreTools::tr(), TRACE, QGpCoreTools::Random::uniform(), DinverCore::AbstractForward::valueChanged(), DinverCore::RealSpace::variableParameter(), and DinverCore::RealSpace::variableParameterCount().

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), and InversionThread::run().

  {
    TRACE;
    // Adjust number of threads
    if(nThreads>CoreApplication::instance()->maximumThreadCount()) {
      nThreads=CoreApplication::instance()->maximumThreadCount();
    }
    if(nThreads>_forward->maximumThreadCount()) {
      nThreads=_forward->maximumThreadCount();
    }
    if(nThreads<1) nThreads=1;
    App::stream() << tr("Starting %1 generator thread(s)").arg(nThreads) << endl;

    // Calculate seed model
    Random randomNumber(0);
    if(_generatorModels->activeModels()->count()==0) {
      if(!_forward->firstModel(randomNumber, _terminated)) {
        return false;
      }
    } else {
      // Load one of the best models into _forward
      RealSpace& parameterSpace=_forward->parameterSpace();
      int ndVar=parameterSpace.variableParameterCount();
      const int * model=_generatorModels->bestModels()->model(randomNumber.uniform(0, _generatorModels->bestModels()->count()-1));
      for(int ip=0; ip<ndVar; ip++) {
        parameterSpace.variableParameter(ip)->setGridValue(model[ip]);
      }
      // Some parametrizations may need some updates before proceeding
      _forward->valueChanged();
      // Check validity of exisiting best models
      if( !parameterSpace.isOkDebug()) {
        return false;
      }
    }

    // Init all forwards with this first model
    qDeleteAll(_generators);
    _generators.clear();
    for(int i=0; i<nThreads; i++) {
      AbstractForward * f=_forward->clone();
      RealSpace& parameterSpace=f->parameterSpace();
      parameterSpace.setVariableParameters();
      parameterSpace.adjustRanges(); // Assumed to be ok, because checked before for the first one
      // Init first model for f
      f->copyValues(*_forward);
      Generator * g=new Generator(this, f);
      App::setStream(&App::stream(), g);
      g->setType(type);
      g->setWalkCount(_walkCount);
      _generators.append(g);
    }
    _chrono.start();
    for(QList<Generator *>::iterator it=_generators.begin(); it!=_generators.end(); it++) {
      (*it)->start();
    }
    return true;
  }

void DinverCore::ModelRepository::stop

(

)

References QGpCoreTools::AtomicBoolean::setValue(), and TRACE.

Referenced by InversionThread::terminate().

  {
    TRACE;
    _terminated.setValue(true);
    for(QList<Generator *>::iterator it=_generators.begin(); it!=_generators.end(); it++) {
      (*it)->stop();
    }
  }

void DinverCore::ModelRepository::unlock

(

)

const

Used only by external objects to acces generated models (read only)

References DinverCore::ModelSet::unlock().

Referenced by InversionThread::unlock().

  {
    if(_allModels) {
      _allModels->unlock();
    }
    _generatorModelLock.unlock();
  }

int DinverCore::ModelRepository::validModelCount

(

)

const

References DinverCore::ModelSet::count(), and DinverCore::GeneratorModels::rejectedCount().

Referenced by InversionThread::checkImportModels(), DinverCore::BatchRun::neighborhoodOptimization(), InversionThread::run(), and InversionThread::validModelCount().

  {
    return _allModels->count()-_generatorModels->rejectedCount();
  }

const Parameter * DinverCore::ModelRepository::variableParameter

(

int

paramIndex

)

const

References DinverCore::AbstractForward::parameterSpace(), and DinverCore::RealSpace::variableParameter().

Referenced by InversionThread::variableParameter(), and variableParameterValue().

  {
    const RealSpace& parameterSpace=_forward->parameterSpace();
    return parameterSpace.variableParameter(paramIndex);
  }

int DinverCore::ModelRepository::variableParameterCount

(

)

const

References DinverCore::ModelSet::parameterCount().

Referenced by InversionThread::start(), and InversionThread::variableParameterCount().

  {
    return _allModels ? _allModels->parameterCount() : 0;
  }

double DinverCore::ModelRepository::variableParameterValue	(	int	modelIndex,
		int	paramIndex
	)		const

References DinverCore::ModelSet::model(), DinverCore::Parameter::realValue(), and variableParameter().

Referenced by InversionThread::variableParameterValue().

  {
    return variableParameter(paramIndex)->realValue(_allModels->model(modelIndex)[paramIndex]);
  }

int DinverCore::ModelRepository::visitedModelCount

(

)

const

References DinverCore::ModelSet::count().

Referenced by InversionThread::visitedModelCount().

  {
    if(!_allModels) printf("Blank all models\n");
    return _allModels ? _allModels->count() : 0;
  }

void DinverCore::ModelRepository::wait

(

)

References TRACE.

Referenced by DinverCore::BatchRun::neighborhoodOptimization(), InversionThread::run(), and ~ModelRepository().

  {
    TRACE;
    for(QList<Generator *>::iterator it=_generators.begin(); it!=_generators.end(); it++) {
      if((*it)->isRunning()) {
        (*it)->wait();
      }
    }
    // Flush model queue
    _queueLock.lock();
    processQueue();
    _queueLock.unlock();
    // Clean generators
    qDeleteAll(_generators);
    _generators.clear();
  }

---

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

• DinverCore/ModelRepository.h
• DinverCore/ModelRepository.cpp