simulationModelSetLoader.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2015 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/


#pragma once

#include "entityEditorImpl/entityEditorImplDefines.h"
#include "entityEditorImpl/embarkationInformation.h"
#include "entityEditorImpl/diGuyInformation.h"
#include "entityEditorImpl/sensorSignatureInformation.h"
#include <vrvUtil/signalslib.h>
#include "vrfutil/simulationModelSet.h"
#include <vrfutil/rwForces.h>
#include <vrfutil/vrfSubObjectParameterList.h>
#include <vrfutil/vrfSubObjectParameterEntry.h>
#include <vrfutil/standardSensorObjects.h>
#include <vrfutil/scenarioExplorer.h>
#include <vrfutil/formationTable.h>
#include <vlutil/vlFilename.h>
#include <mtl/envValue.h>
#include <matrix/3dBoundingVolume.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtUnicode.h>
#include <QtCore/QHash>
#include <QtGui/QPixmap>
#include <QtCore/QObject>
#include <vrfobjparam/modelSetEntry.h>

#include <vrfExtProtocol/objectType.h>
#include <entityEditorImpl/orderedObjectTypeList.h>

class DtEnvList;
class DtRwVariableBindingsList;
class DtComponentSystemDescriptorList;
class DtVrfObjectParameters;
class DtComponentSystemDefinition;
class DtSystemParameterData;
class DtEntityEditorScenarioExplorer;
class QTranslator;

namespace makVrf
{
   class DtEntityMapperKey;
}

namespace makVrv
{
   class DtForceManager;
}

class DtObjectType;
class DtModelSet;
class DtComponentSystemDatabase;
class QComboBox;
class DtSimulationModelSetLoader;
class DtEnvironment;
class DtVariableBindingList;

static const int DtTemplateKindBase = 200;

class DT_DLL_entityeditorimpl DtSimulationModelSetLoader : public makVrv::DtVirtualBaseClass
{
public:
   enum LoadFlags
   {
      LoadDataFiles = 0x00000001,
      LoadParameterFiles = 0x00000002,
      LoadSystemFiles = 0x00000004,
      LoadSupportingFiles = 0x00000008,
      LoadStandardSensorObjects = 0x00000010,
      LoadTranslationFiles = 0x00000020,
      LoadAll = LoadDataFiles | LoadParameterFiles | LoadSystemFiles | LoadSupportingFiles | LoadStandardSensorObjects | LoadTranslationFiles
   };

   typedef std::map<DtString, DtVrfObjectParameters*> ParametersMap;

   class EnvironmentContainer
   {
   public:
      EnvironmentContainer();
      EnvironmentContainer(DtEnvironmentSP original);

      virtual ~EnvironmentContainer();

      void seedFrom(DtEnvironmentSP env, DtEnvValueSP root);

      DtEnvironmentSP copyEnvironment(DtEnvironmentSP) const;
      void reparentEnvironmentChildren(DtEnvList*, DtEnvValueSP root) const;

      DtEnvValueSP backup();
      DtEnvValueSP update();

      void remove(DtEnvValueSP originalNode, DtEnvValueSP modifiedNode);
      bool isEmpty() const;

      DtEnvValueSP replace(DtEnvironmentSP env, DtEnvValueSP node, DtEnvValueSP replaceWith);
      void reparentRoots(DtEnvValueSP templateRoot, DtEnvValueSP newRoot) const;

      DtEnvironmentSP myOriginal;
      DtEnvironmentSP myModified;
   };

   typedef boost::shared_ptr<EnvironmentContainer> EnvironmentContainerSP;

   class EntityData : public DtObjectType
   {
   public:
      EntityData();
      virtual ~EntityData();
      EntityData(const DtObjectType& objectType, const DtObjectType& matchType = DtObjectType::nullType());
      EntityData(const EntityData& t);

      //sets the object type
      EntityData& operator=(const DtObjectType&);

      EntityData& operator=(const EntityData&);

      virtual EntityData* clone() const;
      
      //compares to the object type
      bool operator>(const DtObjectType& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      //compares to the object type
      bool operator>(const EntityData& rhs) const
      {
         if (*this < rhs)
         {
            return false;
         }
         else
         {
            return true;
         }
      }

      bool myIsInMasterSMS;
      std::string myDataFile;

      EnvironmentContainerSP myEnvironment;

      DtObjectType myMatchType;
      DtObjectType myOriginalMatchType;

      DtRwVariableBindingsList* myOriginalSystems;
      DtEnvValueSP myOriginalObjectNode;
      DtVariableBindingsList* myOriginalVariableBindings;
      DtFormationTable* myOriginalFormationTable;
      DtVrfSubObjectParameterList* myOriginalSubordinateInformation;
      DtEmbarkationInformation* myOriginalEmbarkationInformation;
      DtDiGuyInformation* myOriginalDiGuyInformation;
      DtSensorSignatureInformation* myOriginalSensorSignatureInformation;
      DtModelSetEntry* myCurrentModelSetEntry;
      DtModelSetEntry myOriginalModelSetEntry;

      DtRwVariableBindingsList* myModifiedSystems;
      DtEnvValueSP myModifiedObjectNode;
      DtVariableBindingsList* myModifiedVariableBindings;
      DtFormationTable* myModifiedFormationTable;
      DtVrfSubObjectParameterList* myModifiedSubordinateInformation;
      DtEmbarkationInformation* myModifiedEmbarkationInformation;
      DtDiGuyInformation* myModifiedDiGuyInformation;
      DtSensorSignatureInformation* myModifiedSensorSignatureInformation;

      bool myIsNew;
      bool myIsDeleted;

      EntityData* myIsReplacing;
      DtSimulationModelSet* mySimulationModelSet;
   };

   typedef std::map<std::string, EntityData*> ParametersData;

   DtSimulationModelSetLoader(makVrv::DtDe&);

   virtual ~DtSimulationModelSetLoader();

   virtual bool load(const DtSimulationModelSet&, LoadFlags flags = LoadAll);
   virtual bool save(const DtFilename&);

   static DtSimulationModelSetLoader& instance(makVrv::DtDe&);
   static void registerInstance(makVrv::DtDe&, DtSimulationModelSetLoader*);

   virtual void setDisplayDe(makVrv::DtDe*);
   virtual makVrv::DtDe& displayDe();

private:
   DtSimulationModelSetLoader(const DtSimulationModelSetLoader&);
   DtSimulationModelSetLoader& operator=(const DtSimulationModelSetLoader&);

public:
   virtual bool hasFileNamed(const std::string& s) const;

   virtual bool addNewDataFile(const std::string&);

   virtual std::string platform(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string uiFilename(const makVrf::DtEntityMapperKey& k) const;

   virtual DtSimulationModelSet* simulationModelSet(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string platformFileType(const makVrf::DtEntityMapperKey& k) const;

   virtual std::string platformKey(const makVrf::DtEntityMapperKey& k) const;

   virtual DtString platformDisplayName(const makVrf::DtEntityMapperKey& k) const;

   virtual DtString platformDisplayDescription(const makVrf::DtEntityMapperKey& k) const;

   DtFilename getSystemDirectory() const;
   DtFilename getFormationDirectory() const;
   DtFilename getGuiDirectory() const;
   DtFilename path() const;

   DtFilename simulationModelSetFilename() const;

   virtual bool openSystemFiles(DtSimulationModelSet* set, const DtFilename& directory);

   virtual bool loadForceHostilityFile(const DtFilename& f);

   virtual bool loadDataFiles(const DtString&, DtSimulationModelSet*, bool fromMasterSMS);

   virtual void loadTemplates(const DtString&, DtSimulationModelSet*);

   virtual void makeTemplate(EntityData*);
   virtual void makeTemplate(const DtObjectType&);

   virtual bool loadParameterFiles(DtSimulationModelSet* sms);

   virtual bool loadModelSet();

   virtual DtModelSetEntry* modelEntry(const DtObjectType&, bool matchPattern = false) const;

   virtual DtString simulationModelSetFor(const DtEntityType&) const;

   virtual DtModelSetEntry createModelSetEntryFrom(DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   virtual DtModelSetEntry createModelSetEntryFrom(const DtObjectType&) const;

   virtual void revertData(const makVrf::DtEntityMapperKey& key);

   virtual EntityData* dataFor(const DtObjectType&) const;

   virtual EntityData* dataFor(DtModelSetEntry*) const;

   virtual bool containsObjectType(const DtObjectType&, bool onlyFromMasterSMS = false, DtString* name = 0) const;

   virtual bool hasModelNamed(const DtString&);

   virtual DtReaderWriter::SearchPaths searchPaths() const;
   virtual std::vector<DtSimulationModelSet*> modelSets() const;

   virtual const ParametersMap& availableParameters() const
   {
      return myAvailableParameters;
   }

   virtual bool createRwVariable(const DtObjectType&, const std::string& rwType, const std::string& rwName, DtReaderWriter*& source,
      DtReaderWriter*& backup);

   virtual void replaceSystem(const DtFilename&);

   virtual bool canAddSubordinatesTo(const DtObjectType&) const;

   virtual bool isModified(const DtObjectType&) const;
   virtual bool isModified(EntityData*) const;
   virtual bool isModified() const;

   virtual bool isNew(const DtObjectType&) const;
   virtual bool isNew(EntityData*) const;

   virtual bool isDeleted(const DtObjectType&) const;
   virtual bool isDeleted(EntityData*) const;

   virtual void deleteModel(DtModelSetEntry*);
   virtual void deleteModel(const DtObjectType&);
   virtual void deleteModel(EntityData*);

   virtual bool changeObjectType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual bool changeMatchType(const DtObjectType& oldType, const DtObjectType& newType);

   virtual void updateGuiInformation(EntityData*);

   virtual void updateSystemData(EntityData*);

   virtual void sharedSystems(const DtFilename& systemFile, std::vector<DtModelSetEntry*>& result) const;

   virtual void loadSystemFile(const DtFilename&);

   virtual void updateDataInformation(EntityData*);

   virtual void convertRegistryToEnvironment(const DtReaderWriterRegistry& data, DtEnvironmentSP env, DtEnvValueSP objectNode) const;

   virtual void removeSystem(DtEnvironmentSP env, const DtString& system, DtEnvValueSP objectNode);

   virtual void addSystem(DtEnvironmentSP env, const DtRwVariableBindings*, DtEnvValueSP objectNode);

   virtual void changeDefaultCategory(const QString& old, const QString& newCat);
   virtual void addDefaultCategories(QComboBox*);

   void setDefaultCategories(const QStringList&);
   void addDefaultCategory(const QString&);
   const QStringList& defaultCategories() const;
   virtual void revertCategories();
   virtual bool hasModifiedCategories() const;

   void setDefaultOverlayLayers(const QStringList&);
   const QStringList& defaultOverlayLayers() const;
   virtual void revertOverlayLayers();
   virtual bool hasModifiedOverlayLayers() const;
   virtual void changeDefaultOverlayLayer(const QString& old, const QString& newCat);
   virtual void addDefaultOverlayLayers(QComboBox*);
   void addDefaultOverlayLayer(const QString&);

   virtual DtRwForces favoritesFor(const DtModelSetEntry*) const;
   virtual DtRwForces backupFavoritesFor(const DtModelSetEntry*) const;
   virtual void setFavoritesFor(DtModelSetEntry*, const DtRwForces&);

   virtual void changeDefaultDeployedCountry(const QString& old, const QString& newCat);
   virtual void addDefaultDeployedCountries(QComboBox*);
   void setDefaultDeployedCountries(const QStringList&);
   void addDefaultDeployedCountry(const QString&);
   const QStringList& defaultDeployedCountries() const;
   virtual void revertDeployedCountries();
   virtual bool hasModifiedDeployedCountries() const;

   virtual DtRwVariableBindings* createVariableBindingsForSystem(const DtFilename&, const DtString& newSystemName);

   virtual std::map<std::string, DtEntityType> templatesForKind(int) const;

   virtual DtModelSetEntry* addNewEntity(const DtObjectType& base, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   virtual DtModelSetEntry* addNewEntity(const std::string& platformType, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   DtModelSetEntry* addNewEntity(EntityData* baseData, const DtObjectType& newType, const DtString& name,
      const DtRwNLengthStringVector& categories, const DtString& uniqueID);

   virtual void removeSystem(const DtFilename&);

   virtual const DtRwVariableBindings* variableBindings() const;

   virtual QPixmap getIcon(const makVrf::DtEntityMapperKey& key, int pointSize = 48,
      bool sizeToFont = false);

   virtual void clearIcons(const makVrf::DtEntityMapperKey& key);

   static DtSimulationModelSetLoader* create(makVrv::DtDe*);

   virtual void changeSubordinateTypes(const DtObjectType& oldType, const DtObjectType& newType);

   virtual DtVrfSubObjectParameterList subordinateObjectsFor(const DtObjectType&) const;
   virtual DtVrfSubObjectParameterList subordinateObjectsFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateSubordinateObjects(const DtObjectType&, const DtVrfSubObjectParameterList&);
   virtual void updateSubordinateObjects(DtEnvironmentSP, DtEnvValueSP objectNode, const DtVrfSubObjectParameterList&);

   virtual void updateFormationTable(const DtObjectType&, const DtFormationTable&);

   virtual DtEmbarkationInformation embarkationInformationFor(const DtObjectType&) const;
   virtual DtEmbarkationInformation embarkationInformationFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateEmbarkationInformation(const DtObjectType&, const DtEmbarkationInformation&);
   virtual void updateEmbarkationInformation(DtEnvironmentSP, DtEnvValueSP objectNode, const DtEmbarkationInformation&);

   virtual DtDiGuyInformation diGuyInformationFor(const DtObjectType&) const;

   virtual void updateDiGuyInformation(const DtObjectType&, const DtDiGuyInformation&);

   virtual DtSensorSignatureInformation sensorSignatureInformationFor(const DtObjectType&) const;
   virtual DtSensorSignatureInformation sensorSignatureInformationFor(DtEnvironmentSP, DtEnvValueSP root) const;

   virtual void updateSensorSignatureInformation(const DtObjectType&, const DtSensorSignatureInformation&);
   virtual void updateSensorSignatureInformation(DtEnvironmentSP, DtEnvValueSP root, const DtSensorSignatureInformation&);

   virtual DtFormationTable* formationTableFor(const DtObjectType&);
   virtual DtFormationTable* originalFormationTableFor(const DtObjectType&);

   virtual Dt3dBoundingVolume boundingVolumeFor(const DtObjectType&) const;

   virtual bool isAggregate(const DtObjectType&) const;

   bool loaded() const
   {
      return myLoaded;
   }

   const DtOrderedObjectTypeList<EntityData*>& entityData() const
   {
      return myEntityData;
   }

   virtual bool isTemplate(const DtObjectType&) const;

   virtual void setForceManagerModified(bool);
   virtual bool forceManagerModified() const;

   virtual bool saveData();

   virtual bool saveFavorites();

   virtual DtObjectType templateObjectType(const std::string& parameterType) const;

   virtual void addInternalItem(const std::string&, bool markDataAsWell = true);

   virtual std::vector<DtReaderWriter*> supportPointsFor(const DtObjectType&) const;

   virtual DtObjectType uniqueEntityTypeFrom(const DtObjectType&) const;

   virtual makVrv::DtUnicode systemNameForSystem(const std::string&, DtFilename& fullFilename) const;

   boost::signal<void ()> signal_preloadSimulationModelSet;
   boost::signal<void ()> signal_simulationModelSetLoaded;
   boost::signal<void (std::vector<EntityData*>)> signal_newDataFileAdded;
   boost::signal<void (EntityData*)> signal_entityEntryAboutToBeRemoved;
   boost::signal<void (EntityData*)> signal_entityEntryAdded;

public:
   const DtModelSet* modelSet() const;
   DtModelSet* modelSet();

   virtual makVrv::DtForceManager* forceManager();

   const DtSimulationModelSet& simulationModelSet() const;
   const DtFilename& parameterFilename() const;
   const DtComponentSystemDatabase* systemDatabase() const;
   DtFilename modelSetDirectory() const;

   virtual void forceRemoved(DtForceType forceType);

   const DtRwForces& allForces() const;

   virtual std::vector<const DtComponentSystemDefinition*> systemDefinitionsFor(const DtObjectType& o) const;

   virtual const DtReaderWriter* findVariable(const DtVariableBindingsList&, const DtString&) const;
   virtual const DtReaderWriter* findOriginalVariable(const makVrf::DtEntityMapperKey& emk, const DtString&) const;
   virtual const DtReaderWriter* findModifiedVariable(const makVrf::DtEntityMapperKey& emk, const DtString&) const;
   virtual DtReaderWriter* findVariable(const DtVariableBindingsList&, const DtString&);
   virtual DtReaderWriter* findOriginalVariable(const makVrf::DtEntityMapperKey& emk, const DtString&);
   virtual DtReaderWriter* findModifiedVariable(const makVrf::DtEntityMapperKey& emk, const DtString&);
   virtual const DtReaderWriter* variableFromAnyPlatform(const DtString& varName) const;

   virtual DtVrfObjectParameters* platformParameters(const makVrf::DtEntityMapperKey& key) const;

   virtual const DtStandardSensorObjects& standardSensorObjects() const;
   virtual DtStandardSensorObjects& standardSensorObjects();
   virtual bool processModelSet(DtSimulationModelSet*, LoadFlags flags = LoadAll, bool isMasterSMS = false);

protected:
   virtual void markInternalItemsAsReadOnly(DtVariableBindingsList*);

   virtual const DtReaderWriter* findVariable(const DtString& var, const DtReaderWriter* rw) const;

   virtual void loadSystemFilesFromDirectory(const QString& directoryName, const DtVariableBindingsList& variableBindings);

   virtual void addVariableReferences(DtReaderWriter* source, DtRwVariableBindings* toBindings) const;

   virtual void cleanup();

   virtual bool saveForceHostility(const DtFilename& filename);

   virtual bool warned(const DtFilename&);
   virtual void removeEntityFromSubObjects(const DtObjectType&);

   virtual void mergeFavoritesIntoModelSet(DtModelSet* favorites, DtModelSet* set);

   virtual DtVariableBindingsList* copyBindingsList(const DtVariableBindingsList* orig) const;

   virtual EntityData* createParameterDataFrom(DtVrfObjectParameters*) const;

   virtual bool updateFromPlatform(const DtReaderWriter* oldRegData, DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   
   virtual bool traverseRwObject(const DtReaderWriter* rwObject, DtEnvironmentSP env, DtEnvValueSP objectNode) const;
   virtual void addElementFromSystemBinding(DtEnvironmentSP env,
         DtEnvValueSP parentElement, DtSystemParameterData* paramData) const;

   virtual DtFormationTable* formationTableFor(DtEnvironmentSP, DtEnvValueSP objectNode) const;

   virtual void updateFormationTable(DtEnvironmentSP, DtEnvValueSP objectNode, const DtFormationTable&);

   virtual std::vector<EntityData*> addDataFromFile(const DtString& file, 
      DtSimulationModelSet* set, bool isMasterSMS,
      bool signalAddition = true, bool isTemplate= false);

   virtual DtModelSetEntry* addModelSetEntryFromEnvironment(DtEnvironmentSP, DtEnvValueSP node);
   virtual void addToInternalCategories(DtModelSetEntry* entry);

   virtual void addEntityDataEntry(EntityData*, bool signal = true);
   virtual void removeEntityDataEntry(EntityData*, bool signal = true);

   virtual ParametersMap::const_iterator findAvailablePlatform(DtString platform) const;
   virtual ParametersData::const_iterator findAvailableParameter(DtString platform) const;
   virtual ParametersData::const_iterator findAvailableParameterFromFile(const DtFilename& platform) const;

   virtual void swapCurrentEntry(EntityData*, DtModelSetEntry*);

   virtual DtString filenameFromEntityName(const DtString& name) const;

protected:
   QStringList myWarned;
   DtSimulationModelSet* mySimulationModelSet;
   DtComponentSystemDatabase* mySystemDatabase;
   DtFilename        myParameterFilename;
   DtModelSet*       myModelSet;
   DtRwForces        myAllForces;
   QStringList       myDefaultCategories;
   QStringList       myDefaultOverlayLayers;
   QStringList       myDefaultDeployedCountries;
   makVrv::DtDe&     myDe;
   makVrv::DtDe*     myDisplayDe;
   bool myLoaded;
   DtStandardSensorObjects myStandardSensorObjects;

   DtOrderedObjectTypeList<EntityData*> myEntityData;

   DtEntityEditorScenarioExplorer* myScenarioExplorer;

   ParametersMap myAvailableParameters;
   ParametersData myParametersData;

   std::set<std::string> myInternalItems;
   DtModelSet* myFavoritesModelSet;
   DtModelSet* myBackupFavoritesModelSet;

   typedef std::map<DtModelSetEntry*, EntityData*> EntityDataByEntry;
   EntityDataByEntry myEntityDataByEntry;

   std::vector<QTranslator*> myTranslators;
   bool myForceManagerModified;
};

inline DtFilename DtSimulationModelSetLoader::simulationModelSetFilename() const
{
   if (mySimulationModelSet)
   {
      return mySimulationModelSet->filename();
   }
   else
   {
      return "";
   }
}

inline const DtSimulationModelSet& DtSimulationModelSetLoader::simulationModelSet() const
{
   return *mySimulationModelSet;
}

inline const DtModelSet* DtSimulationModelSetLoader::modelSet() const
{
   return myModelSet;
}

inline DtModelSet* DtSimulationModelSetLoader::modelSet()
{
   return myModelSet;
}

inline const DtFilename& DtSimulationModelSetLoader::parameterFilename() const
{
   return myParameterFilename;
}

inline const DtRwForces& DtSimulationModelSetLoader::allForces() const
{
   return myAllForces;
}

inline const QStringList& DtSimulationModelSetLoader::defaultCategories() const
{
   return myDefaultCategories;
}

inline void DtSimulationModelSetLoader::setDefaultCategories(const QStringList& l)
{
   myDefaultCategories = l;
}

inline void DtSimulationModelSetLoader::addDefaultCategory(const QString& l)
{
   myDefaultCategories.push_back(l);
}

inline const QStringList& DtSimulationModelSetLoader::defaultOverlayLayers() const
{
   return myDefaultOverlayLayers;
}

inline void DtSimulationModelSetLoader::setDefaultOverlayLayers(const QStringList& l)
{
   myDefaultOverlayLayers = l;
}

inline void DtSimulationModelSetLoader::addDefaultOverlayLayer(const QString& l)
{
   myDefaultOverlayLayers.push_back(l);
}

inline const QStringList& DtSimulationModelSetLoader::defaultDeployedCountries() const
{
   return myDefaultDeployedCountries;
}

inline void DtSimulationModelSetLoader::setDefaultDeployedCountries(const QStringList& l)
{
   myDefaultDeployedCountries = l;
}

inline void DtSimulationModelSetLoader::addDefaultDeployedCountry(const QString& l)
{
   myDefaultDeployedCountries.push_back(l);
   myDefaultDeployedCountries.sort();
}

extern DT_DLL_entityeditorimpl makVrf::DtEntityMapperKey mapperKeyConversion(const DtObjectType&, int force);

inline bool operator>(const DtObjectType& lhs, const DtSimulationModelSetLoader::EntityData& rhs)
{
   return !(lhs.operator<(rhs));
}

class DT_DLL_entityeditorimpl DtEntityEditorScenarioExplorer : public DtScenarioExplorer
{
public:
   DtEntityEditorScenarioExplorer(makVrv::DtDe&, DtSimulationModelSet* baseSet, DtSimulationModelSetLoader::LoadFlags, DtSimulationModelSetLoader*);

   virtual ~DtEntityEditorScenarioExplorer();

   virtual void loadAllSmsFiles();

protected:
   virtual void processModelSet(DtSimulationModelSet*);

protected:
   makVrv::DtDe& myDe;
   DtSimulationModelSet* mySimulationModelSet;
   DtSimulationModelSetLoader* mySimulationModelSetLoader;
   DtSimulationModelSetLoader::LoadFlags myLoadFlags;
};