---

sct_api_server.cpp

Go to the documentation of this file.

/*
Simple sctapi example
DR
*/

#include "SctApiTest.hh"
#include <is/isinfo.h>
#include <iostream>
#include <string>
#include <sstream>
#include <cstdlib>
#include <ipc/object.h>
#include <ipc/server.h>

// ROOT include files
#include <TH1.h>
#include <TH2.h>
#include <TH3.h>
#include <TKey.h>
#include <TFile.h>
#include <TSystem.h>
#include <TRandom.h>
#include <TROOT.h>

// Matt's RawRODData stuff
#include "Sct/IS/IOManagerIS.h"
#include "Sct/File/IOManagerFile.h"
#include "Sct/ISProxy/IOManagerISProxy.h"
#include "Sct/SctNames.h"
#include "SctData/RawScanResult.h"
#include "SctData/ModuleConfiguration.h"
#include "SctData/ScanHeader.h"
#include "SctData/ScanPoints.h"
#include "SctData/mVThresholdVariable.h"
#include "SctData/StrobeDelayVariable.h"
#include "SctData/NullVariable.h"
#include "SctData/DefaultVariable.h"
#include "CalibrationController/IS/TestData.h"

#include "CommonWithDsp/ABCD/ABCDscans.h"

//Server names
#include "servernames.h"

enum scanType {STROBE_DELAY,THREE_POINT_GAIN};

using namespace SctData;
using namespace Sct;
using namespace Sct::IS;
using namespace Sct::File;
using namespace Sct::ISProxy;

string dataPath = "$SCT_DAQ_ROOT/installed/share/SctTestApiData/";
string filePrefix = "strun";

class SCTAPI : public IPCObject, public virtual SctApiTest_T_sctapi {
public:
    SCTAPI(const char* oid, IPCServer* server, IPCPartition* thepartition) : IPCObject(oid, server) {
        configname = "UNDEFINED";
        p = thepartition;
    }
    virtual ~SCTAPI() {}
    virtual char* ping(SctApiTestStatus* status, char* teststring) {
        char* c = new char[12];
        status->returnCode = SctApiTestReply_Success;
        strcpy(c, "Hello World");
        return c;
    }

    void publishTest(TestData& t) {
        string name = SctNames::getControlDataName();
        name += ".";

        ostringstream s;
        s << "TestData." << t.runNumber << "." << t.startScanNumber;

        name += s.str();
        ISInfoDictionary& is = SctNames::getISDictionary();
        ISInfo::Status stat;

        if (is.contains(name.c_str())) {
            stat = is.update(name.c_str(), t);
        } else {
            stat = is.insert(name.c_str(), t);
        }
    }


    virtual void initialise(SctApiTestStatus* status) {
        status->returnCode = SctApiTestReply_Success;
    }
    virtual long configure(SctApiTestStatus* status, char* newconfigname) {
        status->returnCode = SctApiTestReply_Success;
        configname=newconfigname;
        return 0;
    }
    virtual char* getConfigName(SctApiTestStatus* status) {
        status->returnCode = SctApiTestReply_Success;
        char *c = new char[configname.length()+1];
        strcpy(c,configname.c_str());
        return c;
    }

    virtual void doStrobeDelayScan(SctApiTestStatus* status) {
        cout <<"DUMMY STROBE DELAY" <<endl;

        double* testpoints = new double[1];
        testpoints[0]=0;

        TestData test;
        test.testName="StrobeDelayTest";
        test.runNumber=551;
        test.startScanNumber=12;
        test.testVariable=0;     // trim
        test.nScans=1;
    test.status=test.COMPLETED;
        test.testPoints_size = 1;
        test.testPoints=testpoints;

        try {
            publishTest(test);
        publishRawDataObjects(test, StrobeDelayVariable::instance());
            status->returnCode = SctApiTestReply_Success;
        } catch(Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what()<<endl;
        }
    }

    virtual void doThreePointGainScan(SctApiTestStatus* status) {
        cout <<"DUMMY 3-PT GAIN" << endl;

        double* testpoints = new double[3];
        testpoints[0] = 1.50;
        testpoints[1] = 2.00;
        testpoints[2] = 2.50;

        TestData test;
        test.testName="NPtGainTest";
        test.runNumber=551;
        test.startScanNumber=13;
        test.testVariable=42;            // 42=calcharge
        test.nScans=3;
    test.status=test.COMPLETED;
        test.testPoints_size = 3;
        test.testPoints=testpoints;
        publishTest(test);

        status->returnCode = SctApiTestReply_Success;
        try {
        publishRawDataObjects(test, mVThresholdVariable::instance());
            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() << endl;
        }
    }
    virtual void doResponseCurveScan(SctApiTestStatus* status) {
        cout <<"DUMMY RESPONSE CURVE" << endl;
        try {
            double* testpoints = new double[10];
            testpoints[0]=0.50;
            testpoints[1]=0.75;
            testpoints[2]=1.00;
            testpoints[3]=1.25;
            testpoints[4]=1.50;
            testpoints[5]=2.00;
            testpoints[6]=3.00;
            testpoints[7]=4.00;
            testpoints[8]=6.00;
            testpoints[9]=8.00;

            TestData test;
            test.testName="NPtGainTest";
            test.runNumber=551;
            test.startScanNumber=44;
            test.testVariable=42;            // 42=calcharge
            test.nScans=10;
        test.status=test.COMPLETED;
            test.testPoints_size = 10;
            test.testPoints=testpoints;
            publishTest(test);

        publishRawDataObjects(test, mVThresholdVariable::instance());
            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() << endl;
        }
    }

    virtual void doTrimScan(SctApiTestStatus* status) {
        cout << "DUMMY TRIM SCAN"<<endl;
        try {

            double* testpoints = new double[28];
            for(int i=0; i<28; i++) {
                if (i<16) {
                    testpoints[i]=i;
                } else {
                    testpoints[i]=((i%4)+1)*4-1;
                }
            }
            TestData test;
            test.testName="TrimRangeTest";
            test.runNumber=551;
            test.startScanNumber=16;
            test.testVariable=6;     // trim
            test.nScans=28;
        test.status=test.COMPLETED;
            test.testPoints_size = 28;
            test.testPoints=testpoints;
            publishTest(test);

            for(int i=16; i<44; i++) {
                short pointintest=i-16;
                short range, point, value;
                if (pointintest<16) {
                    range=0;
                    point=pointintest;
                    value=point;
                } else {
                    range=(pointintest-16)/4+1;
                    point=(pointintest-16)%4;
                    value=(point+1)*4-1;
                }
                cout << "trim range: " << range << " value " << value << endl;
                ModuleConfiguration* m=new ModuleConfiguration();
                for (unsigned ichip=0; ichip<12; ++ichip) {
                    m->getChipConfiguration(ichip).setTrimRange(range);
                    for (unsigned ichannel=0; ichannel<128; ++ichannel) {
                        m->getChipConfiguration(ichip).setTrim(ichannel,value);
                        m->getChipConfiguration(ichip).setRcFunctionIndex(3);
                        m->getChipConfiguration(ichip).setRcParam(0,1600);
                        m->getChipConfiguration(ichip).setRcParam(1,8.0);
                        m->getChipConfiguration(ichip).setRcParam(2,-720);
                    }
                }
                sleep(1);
                publishRawDataObject(test.runNumber, i, mVThresholdVariable::instance(),m);
            }

            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() <<endl;
        }
    }

    virtual void doNoiseScan(SctApiTestStatus* status) {
        cout <<"DUMMY NOISE SCAN"<<endl;

        double* testpoints = new double[1];
        testpoints[0]=0;

        TestData test;
        test.testName="NoiseOccupancyTest";
        test.runNumber=551;
        test.startScanNumber=54;
        test.testVariable=0;     // trim
        test.nScans=1;
    test.status=test.COMPLETED;
        test.testPoints_size = 1;
        test.testPoints=testpoints;

        ModuleConfiguration* m=new ModuleConfiguration();
        double param0s[] = {1619.83, 1628.64, 1658.59, 1789.91, 1527.4, 1695.84, 1630.85, 1576.27, 1600.25, 1628.28, 1652.6, 1696.85};
        double param1s[] = {7.34, 7.55, 8, 8.45, 7.12, 7.93, 7.92, 7.88, 7.46, 7.36, 7.81, 7.96};
        double param2s[] = {-731.83, -735.28, -748.06, -814.46, -684.55, -768.05, -734.21, -704.84, -721.02, -736.24, -746.03, -768.25};

        for (unsigned ichip=0; ichip<12; ++ichip) {
            m->getChipConfiguration(ichip).setRcFunctionIndex(3);
            m->getChipConfiguration(ichip).setRcParam(0, param0s[ichip]);
            m->getChipConfiguration(ichip).setRcParam(1, param1s[ichip]);
            m->getChipConfiguration(ichip).setRcParam(2, param2s[ichip]);
        }

        try {
            publishTest(test);
            publishRawDataObjects(test, mVThresholdVariable::instance(),m);
            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() <<endl;
        }
    }

    virtual void doPipelineScan(SctApiTestStatus* status) {
        cout <<"DUMMY PIPELINE"<<endl;

        double* testpoints = new double[2];
        testpoints[0]=0;
        testpoints[1]=0;

        TestData test;
        test.testName="PipelineTest";
        test.runNumber=551;
        test.startScanNumber=9;
        test.testVariable=0;     // trim
        test.nScans=2;
    test.status=test.COMPLETED;
    test.testPoints_size = 2;
        test.testPoints=testpoints;

        try {
            publishTest(test);
            ModuleConfiguration *m=new ModuleConfiguration();
            publishRawDataObjects(test, DefaultVariable(25),m);

            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() <<endl;
        }
    }

    virtual void doTimeWalkScan(SctApiTestStatus* status) {
        cout <<"DUMMY TIMEWALK"<<endl;

        const unsigned nscans=10;
        double* testpoints = new double[nscans];
        testpoints[0]=1.25;
        testpoints[1]=1.5;
        testpoints[2]=1.75;
        testpoints[3]=2.0;
        testpoints[4]=3.0;
        testpoints[5]=4.0;
        testpoints[6]=5.0;
        testpoints[7]=6.0;
        testpoints[8]=8.0;
        testpoints[9]=10.0;

        TestData test;
        test.testName="TimeWalkTest";
        test.runNumber=551;
        test.startScanNumber=56;
        test.testVariable=0;
        test.nScans=nscans;
    test.status=test.COMPLETED;
        test.testPoints_size = nscans;
        test.testPoints=testpoints;

        try {
            publishTest(test);
            ModuleConfiguration *m=new ModuleConfiguration();
            publishRawDataObjects(test,StrobeDelayVariable::instance(),m);

            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() <<endl;
        }
    }


    virtual void doFullBypassScan(SctApiTestStatus* status) {
        cout <<"DUMMY PIPELINE"<<endl;

        const unsigned nscans=6;

        double* testpoints = new double[nscans];
        for (unsigned index=0; index<nscans; ++index) {
            testpoints[index]=4.0-0.1*index;
        }

        TestData test;
        test.testName="FullBypassTest";
        test.runNumber=551;
        test.startScanNumber=2;
        test.testVariable=0;
        test.nScans=nscans;
    test.status=test.COMPLETED;
        test.testPoints_size = nscans;
        test.testPoints=testpoints;

        try {
            publishTest(test);
            ModuleConfiguration *m=new ModuleConfiguration();
            publishRawDataObjects(test, DefaultVariable(ST_TOKEN),m);

            status->returnCode = SctApiTestReply_Success;
        } catch (Throwable& e) {
            e.sendToMrs(MRS_ERROR);
            cerr << e.what() <<endl;
        }
    }

    virtual void publishRawDataObjects(TestData& testData, const ConfigurationVariable& scan_variable, ModuleConfiguration* moduleConfiguration=0) {
        for (unsigned int scanNumber = testData.startScanNumber; scanNumber < testData.startScanNumber+testData.nScans; ++scanNumber) {
            publishRawDataObject(testData.runNumber, scanNumber, scan_variable, moduleConfiguration);
        }
    }


    virtual void publishRawDataObject(unsigned int runNumber, unsigned int scanNumber, const ConfigurationVariable& scan_variable, ModuleConfiguration* moduleconfiguration=0) {
        TH1F* trighisto = 0;
        TH2F* scan0histo = 0;
        TH2F* scan1histo = 0;
        int histocount=0;

        ostringstream filename;
        filename << dataPath << filePrefix << runNumber << "_" << scanNumber << ".root";
        string fname = filename.str();

        TFile file(fname.c_str());
        if ( ! file.IsOpen( ) ) {
            cout << "Unable to open the file " << fname << "." << endl;
            return;
        }

        // The file is open, publish all histograms in the file
        TKey *key;
        TIter it( file.GetListOfKeys() );
        cout << "Searching for histograms in the file..." << endl;
        while((key=(TKey*)it())) {
            string classname = key->GetClassName();
            string titlename = key->GetTitle();
            string keyname = key->GetName();
            short ncycle = key->GetCycle();
            char fullkeyname[80];
            sprintf(fullkeyname,"%s;%d",keyname.c_str(),ncycle);
            string tfullkeyname(fullkeyname);
            //                     cout << "key: " << fullkeyname << " points to an object of class " << classname << " with title " << titlename << endl;
            if(classname.find("TH1F")!=string::npos && titlename.find("Triggers Sent")!=string::npos) {
                trighisto = (TH1F*)file.Get(fullkeyname);
                histocount++;
                cout << "Obtained pointer to trigger histo " << trighisto << endl;
            }
            if(tfullkeyname.find("h_scan0;1")!=string::npos) {
                scan0histo = (TH2F*)file.Get(fullkeyname);
                //                    cout << "Got scan0histo pointing to " << fullkeyname << endl;
                histocount++;
            }
            if(tfullkeyname.find("h_scan1;1")!=string::npos) {
                scan1histo = (TH2F*)file.Get(fullkeyname);
                //                    cout << "Got scan1histo pointing to " << fullkeyname << endl;
                histocount++;
            }
        }
        if(histocount!=3) {
            cout << "Not found all histos - object not published" << endl;
            return;
        }

        //                cout << "Scan0 histo is " << scan0histo->GetTitle() << endl;
        //                cout << "Scan1 histo is " << scan1histo->GetTitle() << endl;

        ScanHeader* s = new ScanHeader(scanNumber, runNumber, "SCTTestAPI_PseudoModule", scan_variable);

        if (moduleconfiguration==0)
            moduleconfiguration = new ModuleConfiguration();
        ScanPoints* pts = new ScanPoints();

        //Set a flag if the histogram is actually occupancy data rather than just number of events
        bool bOccupancy = false;
        if (scan0histo->GetMaximum() <= 1)
            bOccupancy = true;

        //Factor of 4 is for consistency with other scans
        for (int i=1; i<=trighisto->GetNbinsX(); ++i) {

            if (bOccupancy || (scanNumber>1 && scanNumber<8))
                pts->addPoint(trighisto->GetBinCenter(i),trighisto->GetBinContent(i),0);
            else
                pts->addPoint(trighisto->GetBinCenter(i),trighisto->GetBinContent(i)/4,0);
        }

        //Copy into TH2D - axes don't matter
        gROOT->cd();
        TH2D* link0 = new TH2D("link0", "Link0 data", scan0histo->GetNbinsX(), 0, 100, scan0histo->GetNbinsY(), 0, 100);
        TH2D* link1 = new TH2D("link1", "Link1 data", scan1histo->GetNbinsX(), 0, 100, scan1histo->GetNbinsY(), 0, 100);

        for (int i=0; i<scan0histo->GetNbinsX(); ++i) {
            for (int j=0; j<scan0histo->GetNbinsY(); ++j) {
                if (bOccupancy) {
                    link0->SetBinContent(i+1, j+1, trighisto->GetBinContent(j+1)*scan0histo->GetBinContent(i,j+1));
                    link1->SetBinContent(i+1, j+1, trighisto->GetBinContent(j+1)*scan1histo->GetBinContent(i,j+1));
                } else {
                    link0->SetBinContent(i+1, j+1, scan0histo->GetBinContent(i,j+1));
                    link1->SetBinContent(i+1, j+1, scan1histo->GetBinContent(i,j+1));
                    //cout << i << " , " <<  j << " = " <<  link0->GetBinContent(i+1,j+1)<<endl;
                }
            }
        }

        RawScanResult r(*s, *moduleconfiguration, *pts, *link0, *link1);

        cout << "Created RawScanResult, now publishing: "<< endl << r.getUniqueID() << endl;

        // Publish
        IOParamsIS params(IS_Server_Name);

        try {
            //IOManagerIS::instance().write(r, &params);
            //IOManagerFile::instance().write(r);
            IOManagerISProxy::instance().write(r, &params);
        } catch (IoException& e) {
            e.sendToMrs(MRS_ERROR);
        }
        cout <<"Finished publishing" << endl;
    }


private:
    string configname;
    IPCPartition *p;

};




int main(int argc, char** argv) {
    IPCCore::init(false);
    IPCPartition p(Partition_Name);
    IPCServer* server = new IPCServer(API_Server_Name, p);

    SCTAPI* h = new SCTAPI(API_Object_Name, server, &p);
    if (!h->publish())
        cout << "Failed to publish " << API_Object_Name << endl;
    server->run();
    cout << "Run over" << endl;

    h->withdraw();
    delete h;
    delete server;
}

---