WsfQuantumTaskerProcessor.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFQUANTUMTASKERPROCESSOR_HPP
#define WSFQUANTUMTASKERPROCESSOR_HPP
 
#include <map>
#include <string>
#include <vector>
 
class WsfAssetPerception;
#include "wsf_mil_export.h"
class WsfPerceptionProcessor;
class WsfPlatform;
class WsfProcessor;
class WsfQuantumAllocator;
class WsfQuantumEvaluator;
class WsfQuantumGenerator;
#include "WsfQuantumMatrix.hpp"
class WsfQuantumTask;
class WsfScriptContext;
#include "WsfQuantumAllocator.hpp"
#include "WsfTaskManager.hpp"
#include "script/WsfScriptProcessor.hpp"

class WSF_MIL_EXPORT WsfQuantumTaskerProcessor : public WsfTaskManager, public WsfQuantumMatrix
{
public:
   enum AssetRepresentationType
   {
      cPLATFORM,
      cSYSTEMS,
      cRESOURCES
   };
 
   enum ReallocationStrategyType
   {
      cSTATIC,   // never reallocate any tasks
      cDYNAMIC,  // reallocate any time - whenever max profit suggests it
      cRESPONSE, // only reallocate tasks that were rejected/canceled by assets
      cEVENT     // check for reallocation when a new task appears or an asset drops off (change event)
   };
 
   using AllocationMap = std::map<int, std::set<WsfAssetPerception*>>;
 
   WsfQuantumTaskerProcessor(WsfScenario& aScenario);
   WsfQuantumTaskerProcessor(WsfScenario& aScenario, const std::string& aPartClass, const std::string& aPartName);
   WsfQuantumTaskerProcessor(const WsfQuantumTaskerProcessor& aSrc);
   WsfQuantumTaskerProcessor& operator=(const WsfQuantumTaskerProcessor&) = delete;
   ~WsfQuantumTaskerProcessor() override;


   WsfProcessor* Clone() const override;
   bool          PreInitialize(double aSimTime) override;
   bool          Initialize(double aSimTime) override;
   bool          Initialize2(double aSimTime) override;
   using WsfScriptProcessor::Initialize2;
 
   bool ProcessInput(UtInput& aInput) override;
   void Update(double aSimTime) override;
   bool ProcessMessage(double aSimTime, const WsfMessage& aMessage) override;
   bool ReceiveMessage(double aSimTime, const WsfMessage& aMessage) override;
   void PlatformDeleted(WsfPlatform* aPlatformPtr) override;
 
   const char* GetScriptClassName() const override;
   using WsfScriptProcessor::GetName;
   using WsfScriptProcessor::GetPlatform;



   bool ProcessTaskAssignMessage(double aSimTime, const WsfTaskAssignMessage& aMessage) override;
   bool ProcessTaskStatusMessage(double aSimTime, const WsfTaskStatusMessage& aMessage) override;



   virtual bool AssignTask(double aSimTime, const WsfTask& aTask);
   bool AssignTask(double aSimTime, const WsfTrack& aTrack, const WsfTask& aTask, bool aLockTrack = true) override;



   void PurgeReceivedTask(double aSimTime, WsfTask& aTask) override;
   void PurgeTransmittedTask(double aSimTime, WsfTask& aTask) override;
   void UpdateTaskCorrelation(double aSimTime, WsfTask& aTask) override;



   virtual void SetAssetRepresentation(AssetRepresentationType aType) { mAssetRep = aType; }
   virtual void SetReallocationStrategy(ReallocationStrategyType aType) { mReallocateStrategy = aType; }
   virtual void SetIgnoreAllyTracks(bool aVal) { mIgnoreAllyTracks = aVal; }
 
   WsfQuantumGenerator* Generator() const { return mGeneratorPtr.get(); }
   WsfQuantumEvaluator* Evaluator() const { return mEvaluatorPtr.get(); }



   std::list<WsfTask*> TaskListReceivedOfType(WsfStringId aTaskType);
   std::list<WsfTask*> TaskListReceivedForTrack(const WsfTrackId& aTrackId);
   std::list<WsfTask*> TaskListReceivedOfTypeForTrack(WsfStringId aTaskType, const WsfTrackId& aTrackId);
   std::list<WsfTask*> TaskListReceivedForResourceType(int aResourceType);
   std::list<WsfTask*> TaskListReceivedForResourceName(WsfStringId aResourceName);
 
   std::list<WsfTask*> TaskListAssignedOfType(WsfStringId aTaskType);
   std::list<WsfTask*> TaskListAssignedForTrack(const WsfTrackId& aTrackId);
   std::list<WsfTask*> TaskListAssignedForResourceType(int aResourceType);
   std::list<WsfTask*> TaskListAssignedForResourceName(WsfStringId aResourceName);



   std::set<size_t> AssigneesForTask(WsfQuantumTask* aTaskPtr);
 
   using WsfTaskManager::AssigneesForTask; // don't hide this

   std::set<WsfAssetPerception*> AssetAssigneesForTask(WsfQuantumTask* aTaskPtr);



   bool ReportTaskProgress(double aSimTime, WsfTask& aTask, WsfStringId aSubStatus);
   bool ReportTaskComplete(double aSimTime, WsfTask& aTask, WsfStringId aSubStatus);
   bool RejectTask(double aSimTime, WsfTask& aTask);
   void TaskCompleted(double aSimTime, WsfTask& aTask) override;

   void UpdateEvaluations(double aSimTime, WsfQuantumEvaluator& aEvaluator, std::vector<WsfLocalTrack*>& aPerception) override;
 
   // Disambiguate
   using WsfPlatformPart::GetSimulation;
 
protected:
   using WsfTaskManager::ReportTaskComplete;
   using WsfTaskManager::ReportTaskProgress;
 
   bool AcquireResource(double aSimTime, WsfTask& aTask, const WsfTrack& aTrack) override;
   bool ReleaseResource(double aSimTime, WsfTask& aTask) override;

   bool Rejected(WsfAssetPerception* aAssetPtr, WsfQuantumTask* aTaskPtr);
   bool RejectedAnyTasks(WsfAssetPerception* aAssetPtr);
   bool RejectedByAnyAsset(WsfQuantumTask* aTaskPtr);
   bool CompletedAfter(WsfQuantumTask* aTaskPtr, double aSimTime);
 
   void SetMatrixAssets(double aSimTime);
   void SetMatrixTasks(double aSimTime, std::map<int, std::set<size_t>>& aAllocationMap);
   void SetAllocations(AllocationList& aList);
   void AllocateExtraTasks(AllocationList& aList);
   void AllocateExtraAssets(AllocationList& aList);
 
private:
   TaskList::iterator FindTask(TaskList& aTaskList, WsfTask& aTask);
   using WsfTaskManager::FindTask;
 
   AssetRepresentationType  mAssetRep;
   ReallocationStrategyType mReallocateStrategy;
   bool                     mIgnoreAllyTracks;
   int                      mAssetsId;
   int                      mTasksId;
   int                      mPrevRejectCount;
 
   WsfPerceptionProcessor*               mPerceptionProcessorPtr;
   ut::CloneablePtr<WsfQuantumGenerator> mGeneratorPtr;
   ut::CloneablePtr<WsfQuantumEvaluator> mEvaluatorPtr;
   ut::CloneablePtr<WsfQuantumAllocator> mAllocatorExtraTasksPtr;
   ut::CloneablePtr<WsfQuantumAllocator> mAllocatorExtraAssetsPtr;
 
   std::vector<ut::CloneablePtr<WsfQuantumAllocator>> mAllocators;
 
   std::map<size_t, std::map<int, int>> mRejectedTaskMap; // map from asset id to vector of rejected task ids
   std::map<int, int>                   mRejectedTasks;   // map from task id to 1
 
   std::map<int, double> mCompletedTaskTimes; // map from task id to time reported complete (ignore if task creation
                                              // impetus is more up to date???)
 
   AllocationMap mAllocationMap;
 
   bool mFilterAssignedTasks;
   bool mFilterRejectedTasks;
   bool mFilterCompletedTasks;
   bool mUpdateAssignments;
};
 
#endif