DinverCore/ModelRepository.h

Go to the documentation of this file.

/***************************************************************************
**
**  This file is part of DinverCore.
**
**  This file may be distributed and/or modified under the terms of the
**  GNU General Public License version 2 or 3 as published by the Free
**  Software Foundation and appearing in the file LICENSE.GPL included
**  in the packaging of this file.
**
**  This file is distributed in the hope that it will be useful, but WITHOUT
**  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
**  FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
**  more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program. If not, see <http://www.gnu.org/licenses/>.
**
**  See http://www.geopsy.org for more information.
**
**  Created: 2010-12-22
**  Authors:
**    Marc Wathelet (LGIT, Grenoble, France)
**
***************************************************************************/

#ifndef MODELREPOSITORY_H
#define MODELREPOSITORY_H

#include <QGpCoreTools.h>

#include "DinverCoreDLLExport.h"
#include "Generator.h"

namespace DinverCore {

  class ModelSet;
  class GeneratorModels;
  class NewModel;
  class ParentIndex;
  class AbstractForward;
  class ReportWriter;
  class RealSpace;
  class Parameter;

  class DINVERCORE_EXPORT ModelRepository
  {
  public:
    ModelRepository();
    ~ModelRepository();

    bool operator==(const ModelRepository& o) const;

    void setForward(AbstractForward * f);
    void setStorage();
    void setBestModelCount(int nr);
    bool openReport(const QString& fileName);

    void setWalkCount(int n) {_walkCount=n;}
    void setMaximumModelCount(int n) {_maximumModelCount=n;}
    void setMaximumBestModelCount(int n) {_maximumBestModelCount=n;}
    void setMaximumQueueLength(int l) {_maximumQueueLenght=l;}
    void setMaximumSavedMisfit(double m) {_maximumSavedMisfit=m;}
    void setGiveUp(double gu) {_giveUp=gu;}

    ParentIndex * createModel(double randomValue, RealSpace& parameterSpace) const;
    ModelSet * allModels() {return _allModels;}
    void addReport(NewModel * m, AbstractForward * forward);
    void addModel(NewModel * m);

    void init();
    bool start(int nThreads, Generator::Type type);
    void stop();
    void wait();

    bool importModels(QString fileName, bool strict=true);
    void clear();

    void lock() const;
    void unlock() const;

    int expectedModelCount() const {return _maximumModelCount;}
    int visitedModelCount() const;
    int validModelCount() const;
    int activeModelCount() const;
    int bestModelCount() const;
    int rejectedCount() const;
    int giveUpCount() const;
    int variableParameterCount () const;
    uint checksum() const {return _parameterSpaceChecksum;}

    double misfit(int modelIndex) const;
    const int * model(int modelIndex) const;
    int bestModelIndex() const;

    AbstractForward * forward() {return _forward;}
    const AbstractForward * forward() const {return _forward;}
    const Parameter * variableParameter(int paramIndex) const;
    double variableParameterValue(int modelIndex, int paramIndex) const;

    void printActiveModels();
  private:
    void processQueue();

    int _walkCount;
    int _maximumModelCount;
    int _maximumBestModelCount;
    int _maximumQueueLenght;
    double _maximumSavedMisfit;
    double _giveUp;

    AtomicBoolean _terminated;
    QList<Generator *> _generators;

    AbstractForward * _forward;
    ModelSet * _allModels;

    mutable QReadWriteLock _generatorModelLock;
    GeneratorModels * _generatorModels;

    QMutex _queueLock;
    bool _processingQueue;
    QQueue<NewModel *> _newModels;

    QMutex _reportLock;
    ReportWriter * _report;
    uint _parameterSpaceChecksum;

    QTime _chrono;
  };

} // namespace DinverCore

#endif // MODELREPOSITORY_H