A la découverte du SDK Sophis

Nous avons pu découvrir dans un premier article le logiciel Misys Sophis Value, au travers d’une présentation globale de son architecture et des possibilités qu’il offre.

Nous allons voir aujourd’hui que ses possibilités de base peuvent être très largement étendues par l’utilisation du SDK, mis à disposition avec le logiciel, qui permet à l’utilisateur d’ajouter des fonctionnalités à l’application bien au-delà de ce qui est proposé en standard.

Les possibilités offertes par le SDK, appelé toolkit dans Sophis Value, sont bien trop nombreuses pour pouvoir être énumérées dans cet article, aussi nous nous pencherons sur trois exemples concrets afin d’en entrevoir l’étendue.

Le principe est celui d’un SDK classique : Un ensemble de classes est mis à disposition du développeur, desquelles il peut hériter et redéfinir certaines fonctions.

Dans un premier temps, nous verrons comment ajouter une colonne à la vue portefeuille. Nous utiliserons pour cela un toolkit appelé PortfolioColumn.

Nous enchainerons ensuite par l’implémentation d’un scenario qui peut être lancé en batch afin de réaliser, par exemple, certaines tâches de maintenance la nuit.

Puis nous finirons en intégrant notre propre modèle de pricing pour un modèle d’instruments que nous aurons créé à partir d’un existant.

A noter que les cas présentés ici servent uniquement à comprendre comment fonctionne le code propre aux toolkits. Nous nous concentrons donc sur la technique et non le fonctionnel :)

Avant de créer votre premier toolkit

Afin de faciliter la vie du développeur, Sophis a inclus avec son toolkit un wizard s’intégrant à Visual Studio.

Grâce à ce wizard, vous créez un nouveau projet de type Sophis dans Visual, C++ ou C# selon vos préférences, puis vous choisissez si vous voulez créer un toolkit (.dll) ou un standalone (.exe) utilisant le SDK Sophis.

Ensuite, vous ajoutez les types de toolkit que vous souhaitez à votre projet. Ceci va inclure dans votre projet les fichiers et initialisations nécessaires, ainsi que les classes dont vous avez besoin et leur squelette. Avec éventuellement un code d’exemple pour les toolkit en possédant un. Ne reste plus alors qu’à remplir avec votre code !

Dans le cas d’un toolkit DLL, une fois compilées, vos DLL se retrouveront dans le répertoire de Sophis à l’aide d’une variable d’environnement Windows préalablement définie.

Ca n’est pas plus compliqué que cela pour le moment…

Votre premier toolkit : une PortfolioColumn

Si vous avez utilisé le Wizard, une classe qui hérite de CSMPortfolioColumn – classe du SDK Sophis C# – aura été créée :

public class myPortfolioColumn : sophis.portfolio.CSMPortfolioColumn

Maintenant, vous pouvez surcharger les 3 fonctions  GetPortfolioCell, GetUnderlyingCell et GetPositionCell, suivant que vous vouliez afficher de nouvelles informations au niveau des portefeuilles, des positions et/ou des instruments.

Imaginons que nous voulions mutliplier par 2 la valeurs des positions qui ont une action comme sous-jacent :

public override void GetPositionCell(CSMPosition position,
                                     int activePortfolioCode,
                                     int portfolioCode,
                                     sophis.portfolio.CSMExtraction extraction,
                                     int underlyingCode,
                                     int instrumentCode,
                                     ref SSMCellValue cellValue,
                                     SSMCellStyle cellStyle,
                                     bool onlyTheValue)
{
   //Ici nous indiquons que la valeur à afficher est de type double et nous l’initialisons à 0
   cellStyle.kind = NSREnums.eMDataType.M_dDouble;
   cellValue.doubleValue = 0;

   //On récupère l’instrument associé à la position
   CSMInstrument instrument = position.GetCSRInstrument();
   if (instrument == null)
      return;

   //Et enfin on set la colonne à la valeur désirée si l'instrument est de type equity
   if ((eMInstrumentType)instrument.GetType_API() == eMInstrumentType.M_iEquity)
   {
      cellValue.doubleValue = instrument.GetTheoreticalValue() * 2;
   }
}

Et voilà le résultat : screen ici

A noter que pour les colonnes les plus simples, l’utilisateur peut passer directement par une user column. Il n’y pas de toolkit à construire dans ce cas, Sophis Value possède un langage simple qui peut être implémenté directement dans le logiciel.

Création d’un scénario

Nous allons maintenant créer un scenario en C++ qui va automatiquement créer une nouvelle transaction dont les infos sont récupérées par une fonction tiers.

Toujours à l’aide du Wizard, nous ajoutons notre classe, et le squelette est automatiquement créé:

class MyScenario : public sophis::scenario::CSRScenario

La fonction GetProcessingType() permet de choisir dans quel menu le scenario apparaitra.

Nous remplissons ensuite la fonction Run(), qui est la fonction qui sera appelée lorsque l’utilisateur lancera le scenario :


void MyScenario::Run()
{
   //Création de la transaction, vide pour le moment.
   CSRTransaction *ptrTransaction = CSRTransaction::newCSRTransaction ();
   if (!ptrTransaction)
      return;

   int folioCode = 0;
   int quantity = 0;
   int instrumentCode = 0;
   int brokerCode = 0;

   //On récupère les infos du trade depuis l'extérieur
   if (!RetrieveTradeInformations(folioCode, quantity, instrumentCode, brokerCode))
      return;

   //On set les détails du trade
   ptrTransaction->SetInstrumentCode (instrumentCode);
   ptrTransaction->SetTransactionType (tPurchaseSale);
   ptrTransaction->SetTransactionDate (CSRDay::GetSystemDate());
   ptrTransaction->SetTransactionTime (CSRDay::GetSystemTime());
   ptrTransaction->SetSettlementDate (CSRDay::GetSystemDate()+1);
   ptrTransaction->SetAccountancyDate (CSRDay::GetSystemDate());

   ptrTransaction->SetFolioCode (folioCode);
   ptrTransaction->SetQuantity (quantity);
   ptrTransaction->SetSpot (gApplicationContext->GetSpot(instrumentCode));  ptrTransaction->SetBroker (brokerCode);  ptrTransaction->SetCounterparty (brokerCode);

   //Enregistre en Base et notifie les autres clients par envoi d’un évenement.
   ptrTransaction->SaveToDatabase ();
}

Un nouveau modèle d’instrument

Pour créer un nouveau modèle d’instrument, on hérite des classes génériques présentes dans l’API Sophis, par exemple le cas d’un modèle de swap ci-dessous :

public class CSMSwapDerived : sophis.instrument.CSMSwap

Ensuite, on surcharge les méthodes que l’on souhaite afin de personnaliser le comportement de notre instrument.

Par exemple, le prix de notre CSMSwapDerived va être calculé par une librairie de pricing mise au point par des Quant.

Ce modèle de pricing doit être appelée par la fonction GetTheoreticalValue(), fonction de CSMInstrument que l’on doit surcharger pour calculer le prix d’un instrument suivant les données de marché que l’on passe en paramètre, et suivant le modèle que l’on a implémenté.

public override double GetTheoreticalValue(sophis.market_data.CSMMarketData market)
{
   //Le modèle de pricing doit être appelé ici
}

Voilà, pour charger vos toolkits, il reste simplement à éditer le fichier de configuration de Sophis de manière idoine pour lui indiquer quelles dll doivent être chargées.

Bien sûr, énormément d’autres toolkits sont possibles : Par exemple, pour le Back Office avec des workflows et statuts personnalisables, des triggers qui sont déclenchés chaque fois qu’une transaction ou un instrument sont créés/modifiés/supprimés, des modèles de volatilités, etc…

Pour conclure, sachez que la documentation Sophis fournie avec l’installation du soft ainsi que les commentaires présents dans les headers de l’API seront vos meilleurs alliés pour vos futurs développements !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *