model.h

//SPDX-License-Identifier:         LGPL-3.0-or-later
/* * eisgenerator - a shared library and application to generate EIS spectra
 * Copyright (C) 2022-2024 Carl Philipp Klemm <carl@uvos.xyz>
 *
 * This file is part of eisgenerator.
 *
 * eisgenerator is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * eisgenerator 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with eisgenerator.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <complex>
#include <cstddef>
#include <string>
#include <vector>
#include <functional>
 
#include "eistype.h"
#include "componant/componant.h"
 
namespace eis
{
 
struct CompiledObject;
 
class Model
{
private:
        Componant *processBrackets(std::string& str, size_t& bracketCounter, size_t paramSweepCount, bool defaultToRange);
        Componant *processBracket(std::string& str, size_t paramSweepCount, bool defaultToRange);
        std::string getParamStr(const std::string& str, size_t index);
        static size_t paramSkipIndex(const std::string& str, size_t index);
        static void addComponantToFlat(Componant* componant, std::vector<Componant*>* flatComponants);
 
        static void sweepThreadFn(std::vector<std::vector<DataPoint>>* data, Model* model, size_t start, size_t stop, const std::vector<fvalue>& omega);
 
        size_t getActiveParameterCount();
 
private:
        Componant *_model = nullptr;
        std::vector<Componant*> _bracketComponants;
        std::string _modelStr;
        std::vector<Componant*> _flatComponants;
        std::string _modelUuid;
        CompiledObject* _compiledModel = nullptr;
 
public:
 
        Model(const std::string& str, size_t paramSweepCount = 100, bool defaultToRange = true);
        Model(const Model& in);
        Model& operator=(const Model& in);
        ~Model();
 
        size_t setParamSweepCountClosestTotal(size_t totalCount);
 
        DataPoint execute(fvalue omaga, size_t index = 0);
 
        std::vector<DataPoint> executeSweep(const Range& omega, size_t index = 0);
 
        std::vector<DataPoint> executeSweep(const std::vector<fvalue>& omega, size_t index = 0);
 
        std::vector<std::vector<DataPoint>> executeSweeps(const Range& omega, const std::vector<size_t>& indecies, bool parallel = false);
 
        std::vector<std::vector<DataPoint>> executeSweeps(const std::vector<fvalue>& omega, const std::vector<size_t>& indecies, bool parallel = false);
 
        std::vector<std::vector<DataPoint>> executeAllSweeps(const Range& omega);
 
        std::string getModelStr() const;
 
        std::string getModelStrWithParam(size_t index);
 
        std::string getModelStrWithParam() const;
 
        size_t getUuid() const;
 
        std::vector<Componant*> getFlatComponants(Componant *model = nullptr);
 
        std::vector<fvalue> getFlatParameters();
 
        std::vector<Range> getFlatParameterRanges();
 
        std::vector<Range> getDefaultParameters();
 
        size_t getParameterCount();
 
        bool compile();
 
        bool isReady();
 
        void resolveSteps(int64_t index);
 
        size_t getRequiredStepsForSweeps();
 
        bool isParamSweep();
 
        std::string getCode();
 
        std::string getTorchScript();
 
        std::string getCompiledFunctionName() const;
 
        std::vector<size_t> getRecommendedParamIndices(eis::Range omegaRange, double distance, bool threaded = false);
};
 
}