MSDevice.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2007-2026 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Abstract in-vehicle device
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <string>
#include <vector>
#include <map>
#include <set>
#include <random>
#include <microsim/MSMoveReminder.h>
#include <microsim/MSNet.h>
#include <microsim/MSVehicleType.h>
#include <microsim/MSVehicleControl.h>
#include <utils/common/Named.h>
#include <utils/common/StringUtils.h>
#include <utils/common/UtilExceptions.h>
#include <utils/options/OptionsCont.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class SUMOVehicle;
class MSTransportable;
class SUMOSAXAttributes;
class MSVehicleDevice;
class MSTransportableDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSDevice : public Named {
public:
    static void insertOptions(OptionsCont& oc);
 
    static bool checkOptions(OptionsCont& oc);
 
 
    static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
 
    static void buildTransportableDevices(MSTransportable& p, std::vector<MSTransportableDevice*>& into);
 
    static std::string getDeviceName(const std::string& id);
 
    static SumoRNG* getEquipmentRNG() {
        return &myEquipmentRNG;
    }
 
    virtual const std::string deviceName() const = 0;
 
    static void cleanupAll();
 
    static const std::string LOADSTATE_DEVICENAMES;
 
public:
    MSDevice(const std::string& id) : Named(id) {
    }
 
 
    virtual ~MSDevice() { }
 
 
    virtual void generateOutput(OutputDevice* /*tripinfoOut*/) const {
    }
 
    virtual void saveState(OutputDevice& out) const;
 
    virtual void loadState(const SUMOSAXAttributes& attrs);
 
    virtual std::string getParameter(const std::string& key) const {
        throw InvalidArgument("Parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
    }
 
    virtual void setParameter(const std::string& key, const std::string& value) {
        UNUSED_PARAMETER(value);
        throw InvalidArgument("Setting parameter '" + key + "' is not supported for device of type '" + deviceName() + "'");
    }
 
protected:
 
    static void insertDefaultAssignmentOptions(const std::string& deviceName, const std::string& optionsTopic, OptionsCont& oc, const bool isPerson = false);
 
 
    template<class DEVICEHOLDER>
    static bool equippedByDefaultAssignmentOptions(const OptionsCont& oc, const std::string& deviceName, DEVICEHOLDER& v, bool outputOptionSet, const bool isPerson = false);
 
 
private:
    static std::map<std::string, std::set<std::string> > myExplicitIDs;
 
    struct DefaultAssignment {
        std::string prefix;
        std::string parameterKey;
        std::string probabilityKey;
        bool deterministic = false;
        bool numberGiven = false;
        double probability = 0;
        bool nameGiven = false;
    };
    static const DefaultAssignment& getDefaultAssignment(const OptionsCont& oc, const std::string& deviceName, const bool isPerson);
    static std::map<std::string, DefaultAssignment> myDefaultAssignments[2];
 
    static SumoRNG myEquipmentRNG;
 
 
private:
    MSDevice(const MSDevice&);
 
    MSDevice& operator=(const MSDevice&);
 
};
 
 
template<class DEVICEHOLDER> bool
MSDevice::equippedByDefaultAssignmentOptions(const OptionsCont& oc, const std::string& deviceName, DEVICEHOLDER& v, bool outputOptionSet, const bool isPerson) {
    const DefaultAssignment& defaults = getDefaultAssignment(oc, deviceName, isPerson);
    const std::string& prefix = defaults.prefix;
    // assignment by number
    bool numberGiven = defaults.numberGiven;
    double probability = defaults.probability;
    // assignment by name
    bool haveByName = false;
    const bool nameGiven = defaults.nameGiven;
    if (nameGiven) {
        if (myExplicitIDs.find(deviceName) == myExplicitIDs.end()) {
            myExplicitIDs[deviceName] = std::set<std::string>();
            const std::vector<std::string> idList = OptionsCont::getOptions().getStringVector(prefix + ".explicit");
            myExplicitIDs[deviceName].insert(idList.begin(), idList.end());
        }
        haveByName = myExplicitIDs[deviceName].count(v.getID()) > 0;
    }
    // assignment by abstract parameters
    bool haveByParameter = false;
    bool parameterGiven = false;
    const std::string& key = defaults.parameterKey;
    if (v.getParameter().hasParameter(key)) {
        parameterGiven = true;
        haveByParameter = StringUtils::toBool(v.getParameter().getParameter(key, "false"));
    } else if (v.getVehicleType().getParameter().hasParameter(key)) {
        parameterGiven = true;
        haveByParameter = StringUtils::toBool(v.getVehicleType().getParameter().getParameter(key, "false"));
    } else if (v.getVehicleType().getParameter().hasParameter(defaults.probabilityKey)) {
        // override global options
        numberGiven = true;
        probability = StringUtils::toDouble(v.getVehicleType().getParameter().getParameter(defaults.probabilityKey, "0"));
    }
    //std::cout << " deviceName=" << deviceName << " holder=" << v.getID()
    //    << " nameGiven=" << nameGiven << " haveByName=" << haveByName
    //    << " parameterGiven=" << parameterGiven << " haveByParameter=" << haveByParameter
    //    << " numberGiven=" << numberGiven << " haveByNumber=" << haveByNumber
    //    << " outputOptionSet=" << outputOptionSet << "\n";
    if (haveByName) {
        return true;
    } else if (parameterGiven) {
        return haveByParameter;
    } else if (numberGiven) {
        if (defaults.deterministic) {
            return MSNet::getInstance()->getVehicleControl().getQuota(probability) == 1;
        } else if (probability > 0) {
            if (v.getParameter().hasParameter(LOADSTATE_DEVICENAMES)) {
                // replicate probabilistic assignment
                const std::vector<std::string> lsdn = StringTokenizer(v.getParameter().getParameter(LOADSTATE_DEVICENAMES)).getVector();
                return std::find(lsdn.begin(), lsdn.end(), deviceName) != lsdn.end();
            } else {
                return RandHelper::rand(&myEquipmentRNG) < probability;
            }
        } else {
            return false;
        }
    } else {
        return !nameGiven && outputOptionSet;
    }
}