SctApi.idl

Go to the documentation of this file.

#ifndef IPC_IDL
#include "ipc/ipc.idl"
#define IPC_IDL
#endif

#include "SctApi/config.h"

#include "sctConfIPC/configuration.idl"
#include "Sct/Addressing.idl"

module Sct_SctApi {
  exception SctApiException {
    string detail;
  };

  typedef sequence <long> DataBlock;
  typedef sequence <short> CharBlock;
  typedef sequence <CharBlock> CharMatrix;
  typedef sequence <string> DebugOptionList;
  typedef sequence <sctConf::BOCChannelConfig> BOCChannelList;
  typedef sequence <string> NameList;
  typedef sequence <double> BOCMonitorSequence;

  struct NameValue {
    string name;
    float value;
  };

  typedef short RODTriggerFirstType;
  typedef long  RODTriggerSecondType;
  struct RODTrigger {
    RODTriggerFirstType  first;
    RODTriggerSecondType second;
  };
  
  typedef sequence <RODTrigger> RODTriggers;
  typedef sequence <short> TIMTriggers;
  typedef short TIMTrigger;

  typedef sequence <NameValue> NameValueList;

  enum BankType {PHYSICS_CONFIG, SCAN_CONFIG, CALIBRATION_CONFIG};

  enum RunType {PHYSICS_RUN_TYPE, CALIBRATION_RUN_TYPE};

  enum EventFormatType {NORMAL_EVENT_FORMAT, EXPANDED_EVENT_FORMAT, RAW_EVENT_FORMAT};

  typedef sequence <BankType> BankList;

  interface Trigger : ipc::servant {
    enum Source {SOURCE_UNKNOWN, SOURCE_ROD, SOURCE_TIM_INTERNAL, SOURCE_TIM_EXTERNAL};
  
    void singleL1A();
    void doubleL1A(in unsigned short delay);
    void delayedL1A(in unsigned short delay);
    void calL1A(in unsigned short delay);
    void pulseL1A(in unsigned short delay);
    void softL1A(in unsigned short delay);
    void softCalL1A(in unsigned short delay, in unsigned short delay2);
    void softPulseL1A(in unsigned short delay, in unsigned short delay2);
    void softBc(in unsigned short delay);
    void soft();
    void bc();
    void bcL1A(in unsigned short delay);
    void bcCalL1A(in unsigned short delay, in unsigned short delay2);
    void bcPulseL1A(in unsigned short delay, in unsigned short delay2);

    void setCommIncr(in unsigned short command, in unsigned short incr);
    void getCommIncr(out unsigned short command, out unsigned short incr);

    Source getSource();
    void setSource(in Source s);

    short getRandom();
    void setRandom(in short random);

    double getFrequency();
    void setFrequency(in double freq);

    RODTriggers getRODTriggers(in short scan_point);
    TIMTriggers getTIMTriggers(in short scan_point);
    
    boolean isValidRODTrigger();
    boolean isValidTIMTrigger();
    boolean timNeedsSequencer();

    void clear();

    void addCommand(in RODTriggerFirstType first, in RODTriggerSecondType second);

    string print();
  };


  interface Scan : ipc::servant {

    typedef sequence <double> ScanPoints;
    typedef sequence <unsigned long> TrigPoints;

    enum ScanOptions {full, bits32, loopCalLine, distSlave, debug, tim, nth, nth_rem, enableDataMode, ccode, ope, endoptions};

    void configure(in unsigned short type, in double start, in double stop, in double step);
    void configure2(in unsigned short type, in double start, in double stop, in double step);

    Trigger getTrigger1();
    Trigger getTrigger2();

    // Only throw cause they're not implemented!
    void setTrigger1(in Trigger trig)
      raises(SctApiException);
    void setTrigger2(in Trigger trig)
      raises(SctApiException);

    void setScanVariable1(in unsigned short var);
    void setScanVariable2(in unsigned short var);
    unsigned short getScanVariable1();
    unsigned short getScanVariable2();

    void setNTrigs(in unsigned long nTrigs);
    unsigned long getNTrigs();

    TrigPoints getVariableTrigs();
    void setVariableTrigs(in TrigPoints trigs);
    void setVariableTrigRange(in unsigned short start, in unsigned short end, in unsigned long value);

    ScanPoints getScanPoints1();
    ScanPoints getScanPoints2();
    void setScanPoints1(in ScanPoints scans);
    void setScanPoints2(in ScanPoints scans);

    long getOption(in ScanOptions opt);
    void setOption(in ScanOptions opt, in long val);

    string print();

    void setScanNumber(in unsigned long scan);
    unsigned long getScanNumber();
    void setRunNumber(in unsigned long scan);
    unsigned long getRunNumber();

#if !USE_CONST_SCAN
    sctConf::ModuleList getModuleList(in unsigned long group);
    void setModuleList(in unsigned long group, in sctConf::ModuleList newList);

    unsigned long getNGroups();
    void setNGroups(in unsigned short val);
#endif

#if !USE_CONST_SCAN

    string getStartTime();
    void setStartTime(in string t);
    string getEndTime();
    void setEndTime(in string t);
#endif
  };

  typedef sequence <Scan> ScanList;

  interface ScanMonitor : ipc::servant {
    void newBin(in unsigned long prevTriggers, in unsigned short newBin);
    void finishScan();
  };

  struct AutoConfigResult {
    unsigned long partition;
    unsigned long crate;
    unsigned long rod;

    unsigned long tx;
    unsigned long rx;
  };

  typedef sequence <AutoConfigResult> AutoResultList;






  // Ths Idiosyncrasy is what makes one Crate Controller
  // different from another.
  interface Idiosyncrasy {
    Sct::Corba::UCID ucid();
    string uniqueName();
    string ipcNameOfSctApiCrateServer();
    string infoServiceNameOfScanStatusObject();
  };


  // Direct ROD access (Debug only):
  interface DirectRODAccess {
    /***************** Direct ROD access (Debug only) ********************/
    short dspBlockDump(in unsigned long rod,
                     in long dspStart, in long numWords, in long dspNumber);
    DataBlock dspBlockRead(in unsigned long rod,
                           in long dspStart, in long numWords, in long dspNumber);
    short dspBlockWrite(in unsigned long rod,
                      in DataBlock buffer, in unsigned long dspAddress, in long dspNumber);

    unsigned long dspSingleRead(in unsigned long rod,
                                in unsigned long dspAddr, in long dspNumber);
    void dspSingleWrite(in unsigned long rod,
                        in unsigned long dspAddr, in unsigned long val, in long dspNumber);

    DataBlock readSlaveDsp(in unsigned long rod,
                           in short s, in unsigned long add, in unsigned long words);
//      unsigned long readRodStatusReg(in unsigned long rod,
//                                     in long regNumber);
//      unsigned long readRodCommandReg(in unsigned long rod,
//                                      in long regNumber);
    void printBOCSetup(in unsigned long rod);
    sctConf::ABCDModule getABCDModuleRaw(in unsigned long rod, 
                                         in unsigned long slot, in BankType bank)
      raises(SctApiException);
  };

  // Debug Options:
  interface DebugOptionsCommon {
    void unsetDebugOption(in string opt);
    void setDebugOption(in string opt);
    DebugOptionList listDebugOptions();
    void unsetBusy();
  };
  interface DebugOptionsJustCrate {
    DebugOptionList listEnabledDebugOptions();
    void standardRegisterDumpRod(in unsigned long rod);

    // These are used only by SctApiGUI
    void testLinkOutSelect(in unsigned long rod, in unsigned long link);
    unsigned long testLinkOutRetrieve(in unsigned long rod);

    unsigned long getRodSlot(in unsigned long rod);
    boolean isRODPresent(in unsigned long rod);
  };
  interface DebugOptionsJustTop {
    void standardRegisterDumpURID(in Sct::Corba::URID urid);
  };

  // Low-level primitive access:
  interface PrimitiveAccessLowLevel {
    void awaitResponse(in unsigned long rod);
    DataBlock getResponse(in unsigned long rod);

    void createDebugPrimList()
      raises(SctApiException);
    void addDebugPrimList(in long index, in long id, in long version, in DataBlock body)
      raises(SctApiException);
    void sendDebugPrimList(in unsigned long rod)
      raises(SctApiException);
    void sendDebugSlavePrimList(in unsigned long rod, 
                                in unsigned long slave, in boolean await, in boolean response)
      raises(SctApiException);

    void flashLED(in unsigned long rod, 
                  in unsigned short slaveNumber, in unsigned long period, in unsigned long flashes)
      raises(SctApiException);
    void echo(in unsigned long rod, in DataBlock data)
      raises(SctApiException);
  };

  // Only useful with stdout, therefore debug only
  interface DebugSTDOUT {
    void printABCDModule(in unsigned long mid);
    void printABCDRodModule(in unsigned long mid, in BankType bank);

    void decodeEvent(in unsigned long partition, in unsigned long crate, in unsigned long rod, 
                     in short sl, in short index, in boolean extFlag, in boolean errorType);
  };


  // This is how SctApiGUI and expert scripters 
  // would get access to the low level interface / crate above.
  interface CrateIPC; // fwd declaration to facilitate what follows!
  interface CrateAccessTopLevel {
    CrateIPC getCrate(in Sct::Corba::UCID ucid);
    CrateIPC getCrateLegacy(in unsigned long partition, in unsigned long crate);
    Sct::Corba::UCIDs getCrateUCIDs();
  };

  // Scans and triggers probably kept track of at top level. 
  // Need to be careful about giving different crates 
  // access to them, sometimes is right thing to do. 
  // Would need locking on module list updaters.
  interface ScanMethods {
    Scan createScan();
    Scan getDefaultScan();

    // Nobody seems to use these two:
    Trigger createTrigger();
    // Trigger getDefaultTrigger();

    ScanList knownScans();
  };

  // Translation methods. These are mostly just
  // proxies for configuration server, which was most
  // useful in TApi where it wasn't accessible directly.
  // But these deal with the SctApi's internal mid numbers...
  interface TranslationMethods {
    // Translation
    unsigned long findModuleSerial(in string sn);
    string convertToString(in unsigned long mid);
    unsigned long findModule(in unsigned short mur, in unsigned short number);

    unsigned long findModuleRod(in unsigned long partition, in unsigned long crate, in unsigned long rod, in unsigned long channel);

    //  pair<INT32, INT32> convertToMUR(in unsigned long mid);

    unsigned long findBarrelModule(in unsigned long barrel, in unsigned long row, in short number);
    void convertToBarrelModule(in unsigned long mid, out unsigned long barrel, out unsigned long row, out short number);

    unsigned long findEndcapModule(in long disk, in long ring, in long number);
    void convertToEndcapModule(in unsigned long mid, out long disk, out unsigned long ring, out unsigned long number);
  };

  // DDC stuff. This mostly doesn't need access 
  // to modules. Only exception is setSelect, 
  // which currently doesn't update select parameter 
  // in module configuration, but should do.
  interface SctApiDDCServerMethods {

    const string instanceName = "SctApiDDCServer";

    void requestHardReset(in unsigned long mid);
    void requestIVCurve(in unsigned long mid, in float start, in float stop, in float step, 
                        in unsigned short delay, in float currentLim);
    void setSelect(in unsigned long mid, in boolean value); 
    void setSelectAllInCrate(in long crate, in boolean value);
    void changeRunState(in long state);

    // Direct DDC methods (no module translation)
//     void ddcGetChannelParameter(in long crate, in long channel, in string dpeName,
//                                 out long dpeValue);          // Put timeout in here?

    void ddcSetSingleTimeout(in short timeout);
    short ddcGetSingleTimeout();
    void ddcSetMultipleTimeout(in short timeout);
    short ddcGetMultipleTimeout();

    void ddcChangeState(in long crate, in long channel,
                        in short state);                     // MultipleTimeout
    void ddcChangeStates(in long crate, in string name,
                        in short state);                     // MultipleTimeout
    void ddcChangeStateAll(in long crate,
                           in short state);                  // MultipleTimeout
    void ddcLoadConfiguration(in long crate, 
                              in short state);               // MultipleTimeout
    void ddcHardReset(in long crate, in long channel);       // SingleTimeout
    void ddcHardResetAll(in long crate);                     // MultipleTimeout

    unsigned long ddcGetChannelParameterInt(in long crate, in long channel, in string name);  // SingleTimeout
    float ddcGetChannelParameterFloat(in long crate, in long channel, in string name);        // SingleTimeout
    string ddcGetChannelParameterString(in long crate, in long channel, in string name);      // SingleTimeout

    unsigned long ddcGetCardParameterInt(in long crate, in long card, in string name);  // SingleTimeout
    float ddcGetCardParameterFloat(in long crate, in long card, in string name);        // SingleTimeout
    string ddcGetCardParameterString(in long crate, in long card, in string name);      // SingleTimeout

    unsigned long ddcGetCrateParameterInt(in long crate, in string name);  // SingleTimeout
    float ddcGetCrateParameterFloat(in long crate, in string name);        // SingleTimeout
    string ddcGetCrateParameterString(in long crate, in string name);      // SingleTimeout

    void ddcGetCrateParameters(in long crate, in NameList names, out NameValueList nameValues);   // MultipleTimeout

    // Also set DDC parameters...
    void ddcSetCrateParameterFloat(in long crate, in string name, in float value);  // SingleTimeout
    void ddcSetCardParameterFloat(in long crate, in long card, in string name, in float value);  // SingleTimeout
    void ddcSetChannelParameterFloat(in long crate, in long channel, in string name, in float value);  // SingleTimeout
  };

  interface SctApiDDCServer : 
    ipc::servant,
    SctApiDDCServerMethods {

    const string instanceName = "SctApiDDCServer";

  };


  
  // This currently sends a ROD level trigger. There's a
  // different method for a TIM level trigger, which would 
  // be at a higher level.
  interface TriggerRODLevel {
    void sendL1A(in unsigned long partition, in unsigned long crate, in unsigned long rod);
    void sendRodTrigger(in unsigned long partition, in unsigned long crate, in unsigned long rod, in Trigger trig);
  };

  // These are the only (possibly not even doRawScan) 
  // method(s) that need any "intelligence" in the 
  // top-level API. Unfortunately, it involves a 
  // reasonable amount of intelligence.
  interface DoScanMethods {
    // Scans
    void doScan(in Scan thisScan) // postcondition: hasFinishedScanning()!=true unless the scan has *already* finished! I.e. hasFinishedScanning()==true guarantees that the scan completed.
      raises(SctApiException);
    void doRawScan(in Scan thisScan, in long delay, in long width, in boolean configure, in boolean clockByTwo)
      raises(SctApiException);
    ScanMonitor startAsyncScan(in Scan thisScan)
      raises(SctApiException);
    void abortScan(); // postcondition: hasFinishedScanning()==true;
    boolean hasFinishedScanning();
  };

  // Most of what follows just needs to be forwarded to avoid 
  // the CalibrationController having to know which 
  // Crate/ROD it's talking to. If for some reason 
  // it knows already, then they don't need to be in 
  // the top-level. It doesn't even need to check with 
  // the configuration service as the information is encoded 
  // in the mid parameter.
  // Either way, no module configurations need to be 
  // stored at a level higher than the crate. All it 
  // needs to know is which module is in which crate. 
  // I believe there are no cases where a module has 
  // it's redundant tx pair cross a crate boundary.

  // Modify ABCD methods.
  // Crate-level methods would give error if mid 
  // doesn't correspond to "my" crate.
  interface ModifyABCDMethods {
    void modifyABCDMask(in unsigned long mid, in DataBlock mask);
    void modifyABCDTrims(in unsigned long mid, in CharBlock trims);
    void modifyABCDRC(in unsigned long mid, in unsigned long chip, in unsigned short index, in double p0, in double p1, in double p2 );

    // must be different prototypes
    void modifyABCDVar(in unsigned long typ, in double var);
    void modifyABCDModuleVar(in unsigned long mid, in unsigned long typ, in double var);
    void modifyABCDChipVar(in unsigned long mid, in unsigned long chip, in unsigned long typ, in double var);
    void modifyABCDVarAllModulesOneChip(in unsigned long chip, in unsigned long typ, in double var);

    void modifyABCDVarROD(in unsigned long typ, in double var, in BankList banks);
    void modifyABCDModuleVarROD(in unsigned long mid, in unsigned long typ, in double var, in BankList banks);

    void modifyBOCParam(in unsigned long partition, in unsigned long crate, in unsigned long rod,
                        in unsigned long channel, in unsigned long type, in unsigned long val);

  };

  // Get/set/send module configurations: 
  interface ModuleConfigurationMethods {
    void getABCDModules(in BankType bank)
      raises(SctApiException);
    void getABCDModule(in unsigned long mid, in BankType bank)
      raises(SctApiException);

    void setAutoUpdateBanks(in BankList banks);

    void setABCDModule(in unsigned long mid, in BankList banks)
      raises(SctApiException);
    void setABCDModules(in BankList bank)
      raises(SctApiException);

    void copyABCDModule(in unsigned long mid, in BankType from, in BankList to)
      raises(SctApiException);
    void copyABCDModules(in BankType from, in BankList to)
      raises(SctApiException);

    void sendABCDModule(in unsigned long mid, in BankType bank, in unsigned long type)
      raises(SctApiException);
    void sendABCDModules(in BankType bank)
      raises(SctApiException);

    void storeModuleConfigurations(in BankType bank)
      raises(SctApiException);
    void storeBOCConfigurations()
      raises(SctApiException);

    void configureAllModules()
      raises(SctApiException);

    void loadModuleConfigurations()
      raises(SctApiException);
  };

  // These would be better if the data could come 
  // directly back from the crate SctApi
  interface RetrievingConfigurationMethods {
    sctConf::ABCDModule retrieveModule(in unsigned long mid);
    BOCChannelList currentBOCSetup(in unsigned long partition, in unsigned long crate, in unsigned long rod);

    sctConf::BOCGlobalConfig currentBOCRegisters(in unsigned long partition, in unsigned long crate, in unsigned long rod);

  };

  // These should prbably be crate level only
  interface BOCConfigurationMethods {
    void configureBOC(in unsigned long partition, in unsigned long crate, in unsigned long rod);

    BOCMonitorSequence getBOCMonitorArray(in unsigned long partition, in unsigned long crate, in unsigned long rod);
  };

  // Currently missing from IPC API, but in C++ class:
  // watch out Alan AJB! ...
  interface SavingConfigurationMethods {
    // saveBOCSetup ?
    // restoreBOCSetup ?
  };

  // This sends a TIM level trigger. There's a
  // different method for a ROD level trigger, which would 
  // be at a lower level.
  // TIM access, is this being done completely separately anyway?
  interface TriggerTIMLevel {
    /* *************  TIM functs **************/
    void timSetFrequency(in unsigned long partition, in unsigned long crate, in double trigFreq, in double rstFreq);
    void freeTriggers(in unsigned long partition, in unsigned long crate);
    void stopTriggers(in unsigned long partition, in unsigned long crate);
    void timL1A(in unsigned long partition, in unsigned long crate);
    void timCalL1A(in unsigned long partition, in unsigned long crate, in short delay);
    short timReadRegister(in unsigned long partition, in unsigned long crate, in short value);
    void timWriteRegister(in unsigned long partition, in unsigned long crate, in short reg, in short value);

    unsigned long sendTriggers(in unsigned long partition, in unsigned long crate, in Trigger trig, in unsigned long ntriggers, in unsigned short point_in_scan);
  };

  // Not used much, but high-level thing so belongs here.
  interface AutoConfigure {
    AutoResultList autoConfigureScan()
      raises(SctApiException);
  };

  // Similar, but used internally by histogramming code.
  interface ProbeChecks {
    boolean checkAllModulesProbe(in string chars)
      raises(SctApiException);
  };

  // The output from probe currently assumes only 
  // one ROD, but could be extended to multiple RODs/crates?
  interface ProbeMethods {
    CharBlock probe(in unsigned long partition, in unsigned long crate, in unsigned long rod);
    CharBlock probeHarness(in unsigned long partition, in unsigned long crate, in unsigned long rod, in unsigned long harness);

    CharBlock probeWithTrigger(in unsigned long partition, in unsigned long crate, in unsigned long rod, in Trigger trig);
    CharBlock probeHarnessWithTrigger(in unsigned long partition, in unsigned long crate, in unsigned long rod, 
                      in Trigger trig, in unsigned long harness);
    CharMatrix probeScanHarnessWithTrigger(in unsigned long partition, in unsigned long crate, in unsigned long rod, 
                                          in Scan trig, in unsigned long harness);
  };

  // Again, not much intelligence needs to be at high-level, just distribution.
  interface RunControl {
    void initialiseAll(in unsigned long runNumber)
      raises(SctApiException);

    boolean isInitialised();

    void shutdownAll()
      raises(SctApiException);

    string status();
    void setRunNumber(in unsigned long newRun);
    void setScanNumber(in unsigned long newScan);
    unsigned long getRunNumber();
    unsigned long getScanNumber();

    boolean changeRunMode(in RunType mode);

    boolean changeEventFormat(in EventFormatType format);

    void standardRegisterDumpAll();

    void lasersOff();
  };

  // High-level API shouldn't really have a list of 
  // modules (for coherency), but could amalgamate crates' lists.
  interface ModuleInquiry {
    sctConf::ModuleList getModuleList();
  };


  // Maybe shouldn't be here (only in TApi)
  interface DeprecatedInterfaceOne {
    // Configuration 
    //    void loadConfiguration();
    void loadConfiguration(in string filename)
      raises(SctApiException);
  };

  // Where did these come from? They decode raw output 
  // to stdout, so best kept to TApi...
  interface DeprecatedInterfaceExtraRaw {
    void rawData(in unsigned long partition, in unsigned long crate, in unsigned long rod, 
                 in long delay, in long units, in boolean setMask);
    void rawDataWithTrigger(in unsigned long partition, in unsigned long crate, in unsigned long rod, 
                in long delay, in long units, in boolean setMask, in Trigger trig);
  };


  interface JustCrateMethods :
    Sct_SctApi::DirectRODAccess,
    Sct_SctApi::DebugOptionsJustCrate {
    Idiosyncrasy getIdiosyncrasy();
    string getHostName();
  };

  interface JustCrateMethodsTemporary : // move all elements of this into JustCrateMethods!
    Sct_SctApi::PrimitiveAccessLowLevel,
    Sct_SctApi::DebugSTDOUT {
  };

  interface JustTopLevel : 
    Sct_SctApi::CrateAccessTopLevel,
    Sct_SctApi::DebugOptionsJustTop,
    Sct_SctApi::ScanMethods {
  };

  interface JustTopLevelTemporary : // move all elements of this into JustTopLevel! 
    Sct_SctApi::TranslationMethods {
  };

  interface CommonToTopAndCrate :
    Sct_SctApi::DoScanMethods,
    Sct_SctApi::ModifyABCDMethods,
    Sct_SctApi::ModuleConfigurationMethods,
    Sct_SctApi::RetrievingConfigurationMethods,
    Sct_SctApi::BOCConfigurationMethods,
    Sct_SctApi::SavingConfigurationMethods,
    Sct_SctApi::TriggerRODLevel,
    Sct_SctApi::TriggerTIMLevel,
    Sct_SctApi::AutoConfigure,
    Sct_SctApi::ProbeChecks,
    Sct_SctApi::ProbeMethods,
    Sct_SctApi::RunControl,
    Sct_SctApi::ModuleInquiry,
    Sct_SctApi::DebugOptionsCommon {
  };

  interface CrateIPC :

    ipc::servant,  

    // Crate level:
    Sct_SctApi::JustCrateMethods,
    Sct_SctApi::JustCrateMethodsTemporary, // Remove as soon as it is empty!

    // Top level:
    Sct_SctApi::JustTopLevelTemporary, // Remove as soon as it is empty!

    // Both levels:
    Sct_SctApi::CommonToTopAndCrate,
    
    // Deprecated things that might move elsewhere:
    Sct_SctApi::DeprecatedInterfaceOne,
    Sct_SctApi::DeprecatedInterfaceExtraRaw {

    // Not needed as there will be more than one instance in any case! // const string instanceName = "SctApiCrateIPC";

  };


  // TOP LEVEL:
  interface SctApiIPC : 

    ipc::servant,  

    // Top level:
    Sct_SctApi::JustTopLevel,
    Sct_SctApi::JustTopLevelTemporary, // Remove as soon as it is empty!
    // Not needed ... now separate ... Sct_SctApi::SctApiDDCServerMethods,

    // Both levels:
    Sct_SctApi::CommonToTopAndCrate,

    // Deprecated things that might move elsewhere:
    Sct_SctApi::DeprecatedInterfaceOne {

    const string instanceName = "SctApiImpl";

  };

  // ORIGINAL
  interface SctApiIPCOriginal : 

    ipc::servant,  

    // Crate level:
    Sct_SctApi::JustCrateMethods,

    // Top level:
    Sct_SctApi::JustTopLevel,

    // Both levels:
    Sct_SctApi::CommonToTopAndCrate,

    // Deprecated things that might move elsewhere:
    Sct_SctApi::DeprecatedInterfaceOne,
    Sct_SctApi::DeprecatedInterfaceExtraRaw {

    const string instanceName = "SctApiImpl";

  };

};

---