HighLevelApi.cpp

#include "HighLevelApi.h"
#include "XmlSummaryFile.h"
#include "ModuleData.h"
#include "SctDaqRootFile.h"
#include "Exceptions.h"
#include "Globals.h"

#include "Sct/Env.h"
#include "Sct/IoExceptions.h"
#include "Sct/OmniMarshalling.h"
#include "Sct/SctNames.h"
#include "Sct/ISProxy/IOManagerISProxy.h"
#include "Sct_SctApi/SctApiServer.h"

#include "SctData/ModuleConfiguration.h"
#include "SctData/mVThresholdVariable.h"
#include "SctData/mVfromTrimTargetThresholdVariable.h"
#include "SctData/StrobeDelayVariable.h"
#include "SctData/DefaultVariable.h"
#include "SctData/NullVariable.h"
#include "SctData/RawScanResult.h"
#include "SctData/ScanPoints.h"

#include "CalibrationController/IS/TestData.h"
#include "Sct/AbcdScans.h"

#include <TH1.h>
#include <TH2.h>

#include <sstream>
#include <is/info.h>
#include <is/infodictionary.h>
#include <is/infoiterator.h>
#include <is/inforeceiver.h>
#include <is/infoT.h>

using namespace SctData;
using namespace Sct;
using namespace Sct::IS;
using namespace Sct::ISProxy;
using namespace std;
using namespace boost;
using namespace SctConfiguration;

namespace SctTest {

HighLevelApi::HighLevelApi() : IPCNamedObject<POA_SctTestApi::HighLevelApi>(Sct::SctNames::getPartition(),SctTestApi::HighLevelApi::instanceName){
    try {
    handy_setDataFile("${SCT_DAQ_ROOT}/installed/config/TestConfig/ModuleData.txt");
    } catch (Sct::FileException& fe) {
        fe.sendToMrs(MRS_INFORMATION);
    throw SctTestApi::NoSuchFileException();
    }

    try {
    handy_setXmlSummaryFile("${SCT_DAQ_ROOT}/installed/config/TestConfig/XmlSummary.txt");
    } catch (Sct::FileException& fe) {
        fe.sendToMrs(MRS_INFORMATION);
    throw SctTestApi::NoSuchFileException();
    }

    try {
        XmlSummaryFile file(handy_getXmlSummaryFile());
        XmlSummaryRecord record = file.getNextRecord();
        handy_setModuleSerial(record.serialNumber);
    } catch (Exception& e) {
        e.sendToMrs(MRS_INFORMATION);
    throw SctTestApi::NoSuchFileException();
    }
}

HighLevelApi& HighLevelApi::instance() {
    static HighLevelApi api;
    return api;
}

void HighLevelApi::handy_setModuleSerial(const string & serial) {
    getConfig(serial);
    this->serial = serial;
    if (!data.dataExists(serial)) throw NoDataException("No data for module " + serial, __FILE__, __LINE__);
}

string HighLevelApi::handy_getModuleSerial() const {
    return serial;
}

void HighLevelApi::handy_setDataFile(const string & file) {
    data.load(file);
}

string HighLevelApi::handy_getDataFile() const {
    return data.getFileName();
}

void HighLevelApi::handy_setXmlSummaryFile(const string & file) {
    xmlFile = Env::substituteVariables(file);;
}

string HighLevelApi::handy_getXmlSummaryFile() const {
    return xmlFile;
}


void HighLevelApi::getConfig(string serial) {
    try {
        ModuleConfiguration* c = new ModuleConfiguration();
        if (!config) config = shared_ptr<ModuleConfiguration>(c);
        config->getABCDModule() = configServer->getModuleConfig(serial);
    } catch (ConfigurationException& e) {
        addAndGetConfig(serial);
    }
}

void HighLevelApi::addAndGetConfig(string serial) {
    XmlSummaryFile file(handy_getXmlSummaryFile());
    string xmlFile = "";

    while (xmlFile.length() == 0 && file.hasMoreRecords()) {
        XmlSummaryRecord xsr = file.getNextRecord();
        if (xsr.serialNumber == serial) xmlFile = xsr.xmlFile;
    }

    if (xmlFile.length() == 0) {
        throw NoDataException("No data for module " + serial, __FILE__, __LINE__);
    }

    try {
        configServer->configureModuleFromFile(xmlFile);
        config->getABCDModule() = configServer->getModuleConfig(serial);
    } catch (ConfigurationException& e) {
        throw NoDataException("Could not configure module " + serial, __FILE__, __LINE__);
    }
}

void HighLevelApi::doTest(const TestInfo& info, TestData& data, const SctData::ConfigurationVariable& var) const {
    if (!config) return;
    data.nScans = data.testPoints_size;
    data.runNumber = info.runNumber;
    data.startScanNumber = info.scanNumber;
    data.status = TestData::COMPLETED;

    publishTest(data);
    for (unsigned int i=0; i<data.nScans; ++i) {
        publishScan(info, data.startScanNumber + i, var, *config);        
    }
}

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

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

    name += s.str();
    ISInfoDictionary& is = SctNames::getISDictionary();
    ISInfo::Status stat = is.contains(name);
    if (stat == ISInfo::Success) {
        stat = is.update(name, t);
    } else if (stat==ISInfo::NotFound) {
        stat = is.insert(name, t);
    }
    if (stat!=ISInfo::Success) throw IsException(stat, string("could not publish ")+name, __FILE__, __LINE__);
}

string HighLevelApi::getFileName(const TestInfo& info, unsigned int scanNumber) const{
    ostringstream filename;
    filename << info.path << "/strun" << info.runNumber << "_" << scanNumber << ".root";
    return filename.str();
}

void HighLevelApi::publishScan(const TestInfo& info, unsigned int scanNumber, const ConfigurationVariable& scan_variable, const SctData::ModuleConfiguration& config) const {
    cout << getFileName(info, scanNumber) << endl;
    SctDaqRootFile file(getFileName(info, scanNumber));

    int cycleNum = file.getCycleNum(serial);
    auto_ptr<TH1F> hist0Data = file.getHistData(cycleNum, 0);
    auto_ptr<TH1F> hist1Data = file.getHistData(cycleNum, 1);
    auto_ptr<TH1F> triggerData = file.getTriggerData();

    file.dealWithOccupancy(*hist0Data, *hist1Data, *triggerData, ConfigurationVariableIOHelper::getTypeRep(scan_variable), false);

    auto_ptr<TH2D> link0Data = file.fillData(*hist0Data);
    auto_ptr<TH2D> link1Data = file.fillData(*hist1Data);

    ResultHeader* s = new ResultHeader(scanNumber, info.runNumber, serial, scan_variable);
    ScanPoints* pts = new ScanPoints();

    for (int i=1; i<=triggerData->GetNbinsX(); ++i) {
        pts->addPoint(triggerData->GetBinCenter(i),triggerData->GetBinContent(i),0);
    }

    RawScanResult r(*s, config, *pts, *link0Data.release(), *link1Data.release());

    // Publish
    IOParamsIS params(SctNames::getEventDataName());
    IOManagerISProxy::instance().write(r, &params);    
}


//Corba  methods
void HighLevelApi::setDataFile (const char * file) {
    try {
        handy_setDataFile(file);
    } catch (Sct::FileException& e) {
        throw SctTestApi::NoSuchFileException();
    }
}

char * HighLevelApi::getDataFile () {
    return copyStringToCorba(handy_getDataFile());
}

void HighLevelApi::setXmlSummaryFile (const char * file) {
    try {
        handy_setXmlSummaryFile(file);
    } catch (Sct::FileException& e) {
        throw SctTestApi::NoSuchFileException();
    }
}

char * HighLevelApi::getXmlSummaryFile () {
    return copyStringToCorba(handy_getXmlSummaryFile());
}


void HighLevelApi::setModuleSerial (const char * serial) {
    try {
        handy_setModuleSerial(serial);
    } catch(Sct::FileException& e) {
        throw SctTestApi::NoSuchModuleException();
    }
}

char * HighLevelApi::getModuleSerial () {
    return copyStringToCorba(handy_getModuleSerial());
}

void HighLevelApi::fullBypass() {
    TestData test;
    test.testName="FullBypassTest";
    test.testPoints_size = 6;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = 0;
    for (unsigned index=0; index<test.testPoints_size; ++index) {
        test.testPoints[index]=4.0-0.1*index;
    }
    try {
    doTest(data.getFullBypassInfo(handy_getModuleSerial()), test, *DefaultVariable::instance(ST_TOKEN));
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    std::cout << "LESTERDEBUGWARNING 4532 in " << __FILE__ << std::endl;
    throw SctTestApi::NoDataException();
    }
}

void HighLevelApi::timeWalk() {
    TestData test;
    test.testName="TimeWalkTest";
    test.testPoints_size = 10;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = ST_QCAL;
    test.testPoints[0]=1.25;
    test.testPoints[1]=1.5;
    test.testPoints[2]=1.75;
    test.testPoints[3]=2.0;
    test.testPoints[4]=3.0;
    test.testPoints[5]=4.0;
    test.testPoints[6]=5.0;
    test.testPoints[7]=6.0;
    test.testPoints[8]=8.0;
    test.testPoints[9]=10.0;
    try {
    doTest(data.getTimeWalkInfo(handy_getModuleSerial()), test, StrobeDelayVariable::instance());
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }
    
}

void HighLevelApi::strobeDelay() {
    TestData test;
    test.testName="StrobeDelayTest";
    test.testPoints_size = 1;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = 0;
    test.testPoints[0] = 0;
    try {
    doTest(data.getStrobeDelayInfo(handy_getModuleSerial()), test, StrobeDelayVariable::instance());
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }

}

void HighLevelApi::threePointGain() {
    TestData test;
    test.testName="NPtGainTest";
    test.testPoints_size = 3;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = ST_QCAL;
    test.testPoints[0] = 1.50;
    test.testPoints[1] = 2.00;
    test.testPoints[2] = 2.50;
    try {
    doTest(data.get3PtGainInfo(handy_getModuleSerial()), test, mVThresholdVariable::instance());
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }
}

void HighLevelApi::responseCurve() {
    TestData test;
    test.testName="NPtGainTest";
    test.testPoints_size = 10;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = ST_QCAL;
    test.testPoints[0]=0.50;
    test.testPoints[1]=0.75;
    test.testPoints[2]=1.00;
    test.testPoints[3]=1.25;
    test.testPoints[4]=1.50;
    test.testPoints[5]=2.00;
    test.testPoints[6]=3.00;
    test.testPoints[7]=4.00;
    test.testPoints[8]=6.00;
    test.testPoints[9]=8.00;
    try {
    doTest(data.getResponseCurveInfo(handy_getModuleSerial()), test, mVThresholdVariable::instance());
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }
}

void HighLevelApi::noiseOccupancy() {
    TestData test;
    test.testName="NoiseOccupancyTest";
    test.testPoints_size = 1;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = 0;
    test.testPoints[0] = 0;
    
    try {
    TestInfo info = data.getNoiseOccupancyInfo(getModuleSerial());
    //Check if it is relative to trim target or not
    SctDaqRootFile file(getFileName(info, info.scanNumber));
    int cycleNum = file.getCycleNum(serial);
    auto_ptr<TH1F> hist0Data = file.getHistData(cycleNum, 0);
    double firstBin = hist0Data->GetYaxis()->GetBinCenter(1);
    
    if (firstBin < 0) 
        doTest(info, test, mVfromTrimTargetThresholdVariable::instance());
    else 
        doTest(info, test, mVThresholdVariable::instance());
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }
}

void HighLevelApi::trim() {
    if (!config) return;
 
    try {
    TestInfo info = data.getTrimInfo(handy_getModuleSerial());

    TestData test;
    test.testName="TrimRangeTest";
    test.testPoints_size = 28;
    test.testPoints = new double[28];
    test.testVariable = ST_TRIM;
    test.nScans = test.testPoints_size;
    for(unsigned int i=0; i<test.testPoints_size; i++) {
        if (i<16) {
        test.testPoints[i]=i;
        } else {
        test.testPoints[i]=((i%4)+1)*4-1;
        }
    }
    
    //unsigned int index = 4;
    test.runNumber = info.runNumber;
    test.startScanNumber = info.scanNumber;
    test.status = TestData::COMPLETED;
    
    publishTest(test);
    ModuleConfiguration tempConfig(*config);
    
    for(unsigned int i=0; i<test.nScans; i++) {
        short range, point, value;
        if (i<16) {
        range=0;
        point=i;
        value=point;
        } else {
        range=(i-16)/4+1;
        point=(i-16)%4;
        value=(point+1)*4-1;
        }
        
        for (unsigned ichip=0; ichip<12; ++ichip) {
        tempConfig.getChipConfiguration(ichip).setTrimRange(range);
        for (unsigned ichannel=0; ichannel<128; ++ichannel) {
            tempConfig.getChipConfiguration(ichip).setTrim(ichannel,value);
        }
        }
        
        try {
        publishScan(info, test.startScanNumber + i, mVThresholdVariable::instance(), tempConfig);
        } catch (SctTestException& e) {
        e.sendToMrs(MRS_DIAGNOSTIC);
        throw SctTestApi::NoDataException();
        }
    }
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    return;
    }
}

void HighLevelApi::pipeline() {
    TestData test;
    test.testName="PipelineTest";
    test.testPoints_size = 2;
    test.testPoints = new double[test.testPoints_size];
    test.testVariable = 0;
    test.testPoints[0] = 0;
    test.testPoints[1] = 0;
    try {
    doTest(data.getPipelineInfo(handy_getModuleSerial()), test, *DefaultVariable::instance(ST_MASK));
    } catch (Exception& e) {
    e.sendToMrs(MRS_ERROR);
    throw SctTestApi::NoDataException();
    }
}

}

---