Skip to content
seqIDataMgr.cpp 125 KiB
Newer Older
            for(it = elements.begin(); it != elements.end(); it++)
            {
                log_message << "Ligth Type - Element: \"" << it->first << "\"; Value : \"" << it->second.get() << "\"; ";
            }
            break;
        case IProperty::BLOB:
            log_message << "IProperty::BLOB -> ";
            for(it = elements.begin(); it != elements.end(); it++)
            {
                log_message << "BLOB Type size : " << prop["file"].getSize<unsigned int>() << "; ";
            }
            break;
    }
//    else
    {
//        log_message << "EOF Message";
    }
    return log_message.str();
}

void * SeqDataMgr::fit_mem_realloc(void * old_pointer, size_t new_size)
{
    void * pNew = NULL;
    pNew = realloc(old_pointer, new_size);
    U9_LLOG(__FUNCTION__ << "  ~ " << old_pointer << " -> " << pNew << " ~ " << new_size/2880.f);
    return pNew;
}


int SeqDataMgr::UpdateFitFile(fitsfile * pInFit, fitsfile * ptrFits)
{
     char simple_test[84];
    *(simple_test + 80) = 0;
    char string_value[32];
    int ref_fit_status = 0;
    int update_fit_status = 0;
    int int_value;
    float float_value;
    fits_read_key(pInFit, TFLOAT,    "BZERO", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == KEY_NO_EXIST || ref_fit_status)
    {
        if(ref_fit_status != KEY_NO_EXIST)
        {
            U9_LLOG("ref_fit_status = " << ref_fit_status);
        }
        ref_fit_status = 0;
    }
    else
    {
        fits_update_key(ptrFits, TFLOAT,    "BZERO    ", &float_value, simple_test, &update_fit_status);
    }
    fits_read_key(pInFit, TFLOAT,    "BSCALE", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == KEY_NO_EXIST)
    {
        ref_fit_status = 0;
    }
    else
    {
        fits_update_key(ptrFits, TFLOAT,    "BSCALE   ", &float_value, simple_test, &update_fit_status);
    }
    fits_read_key(pInFit, TSTRING, "CAMERA", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "CAMERA", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "CAPCOMP", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "CAPCOMP", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "DATE-OBS", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "DTEOBSM", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "DETECTOR", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "DETECTOM", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "EXPMODE", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "EXPMODE", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "EXPTIME", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "EXPTIMEM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "FILENAME", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "FILENAME", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "FILTPOLE", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "FILTPOLE", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "FRAME", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "FRAME", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "GAIN", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "GAINM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "ITIME", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "ITIMEM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NCOADDS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NCOADDSM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NCOADDS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NDROPS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NDROPS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NGROUPS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NGROUPS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NOUTPUTS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NOUTPUTS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NRAMPS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NRAMPS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NREADS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NREADSM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NREADS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "NRESETS", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "NRESETS", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "OBJNAME", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "OBJNAMEM", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "RAMPTIM", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "RAMPTIM", &float_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECNM", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECNM", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECH  ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECH  ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECW  ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECW  ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECX1 ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECX1 ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECX2 ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECX2 ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECY1 ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECY1 ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SUBSECY2 ", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SUBSECY2 ", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "SYSSWVER", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "SYSSWVER", &string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "TIME-END", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "TIME-END", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TSTRING, "TIME-OBS", string_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TSTRING, "TIME-OBS", string_value, simple_test, &update_fit_status);
    else ref_fit_status = 0;
    fits_read_key(pInFit, TFLOAT,  "USEREXP", &float_value, simple_test, &ref_fit_status);
    if(ref_fit_status == 0)fits_update_key(ptrFits, TFLOAT,  "USEREXP", &float_value, simple_test, &update_fit_status);

    if(update_fit_status)
    {
        U9_LLOG("Update Fit Status : " << update_fit_status);
        LogCfitsioStack(5);
    }
    return update_fit_status;
}

void SeqDataMgr::LogCfitsioStack(int n)
{
    char simple_test[84];
    *(simple_test + 80) = 0;
    for(int i = 0; i < 7; i++)
    {
        fits_read_errmsg(simple_test);
        U9_LLOG(simple_test);
    }

}

void SeqDataMgr::SaveIncomingFile(const IProperty & prop)
{
    U6_LLOG(__FUNCTION__);
    std::string filenameSASHA, filenameSHINS, dateISO8601;

    if(m_ExpectedBlobs > 0)m_ExpectedBlobs--;
    fitsfile * ptrFitsFileSASHA = NULL;
    fitsfile * ptrFitsFileSHINS = NULL;
    int FitsStatusShins = 0, FitsStatusSasha = 0;
//    std::vector<long> vecNaxes(4, 0);
    long naxes[4] = { 36, 40, 1, 1 };
    int bitpix = 16, naxis = 2;
    long naxesSasha[4] = { 36, 40, 1, 1 };
    int bitpixSasha = 16, naxisSasha = 4;
    char simple_test[84];
    *(simple_test + 80) = 0;
    if(prop.find("file"))
    {
        if(prop["file"].getSize<float>() > 0.0)
        {
            const char * fitsBytes = prop["file"].get().c_str();
            size_t blobSize = prop["file"].getSize<unsigned int>();
            void * pBlobIncoming = malloc(blobSize);
            if(pBlobIncoming)
            {
                int blobLength = from64tobits((char *)pBlobIncoming, fitsBytes);
                if(blobLength < 0)
                {
                    free(pBlobIncoming);
                    A_LLOG("Bad base 64 FITS file WILL NOT BE SAVED");
                }
                else
                {
                    dateISO8601 = prop.getTimeStamp().getFormattedIso8601Str();
                    su::SetTimeWorkingDirectory(dateISO8601);
                    filenameSHINS = "SHARKNIR." + dateISO8601 + "." + m_sashaSetup[suc::instrument_mode] + ".fits";
                    filenameSASHA = "SHARKNIR." + dateISO8601 + "." + m_sashaSetup[suc::instrument_mode] + ".SASHA.fits";
                    if(m_bSaveIncomingBlob)
                        su::debug_save_memory_block((char *)pBlobIncoming, blobSize, filenameSASHA.c_str());
                    fits_open_memfile(&ptrFitsFileSASHA, "", READONLY, &pBlobIncoming, &blobSize, 0, NULL, &FitsStatusSasha);
                    fits_get_img_param(ptrFitsFileSASHA, 4, &bitpixSasha, &naxisSasha, naxesSasha, &FitsStatusSasha);
                    if(FitsStatusSasha)LogCfitsioStack(5);

                    fits_create_file(&ptrFitsFileSHINS, filenameSHINS.c_str(), &FitsStatusShins);
                    fits_create_img(ptrFitsFileSHINS, bitpix, naxis, naxes, &FitsStatusShins);
                    FitsStatusShins = SetFitsValues(ptrFitsFileSHINS);
                    FitsStatusShins = UpdateFitFile(ptrFitsFileSASHA, ptrFitsFileSHINS);
                    fits_resize_img(ptrFitsFileSHINS, bitpixSasha, naxisSasha, naxesSasha, &FitsStatusShins);
                    fits_copy_data(ptrFitsFileSASHA, ptrFitsFileSHINS, &FitsStatusShins);
                    fits_write_chksum(ptrFitsFileSHINS, &FitsStatusShins);
                    fits_flush_file(ptrFitsFileSHINS, &FitsStatusShins);
                    if(FitsStatusShins)LogCfitsioStack(5);
                    FitsStatusShins = 0;
                    fits_close_file(ptrFitsFileSHINS, &FitsStatusShins);
                    if(FitsStatusShins)LogCfitsioStack(5);

                    fits_close_file(ptrFitsFileSASHA, &FitsStatusSasha);
                    U9_LLOG("Saved fits file " << filenameSHINS);
                    m_last_generated_files.push_back(filenameSHINS);

                    free(pBlobIncoming);
                }
            }
            else
            {
                std::stringstream log_msg;
                log_msg << "Error : could not allocate memory for incoming blob";
                E_LLOG(log_msg.str());
                U8_LLOG("");
                throw std::runtime_error(log_msg.str());
            }
        }
    }
void SeqDataMgr::updateInstrumentHeader()
{
    U6_LLOG(__FUNCTION__);
    SInstrumentHeader & ih = m_instrumentHeader;
    if(ih.init)
    {
        ih.init = false;
        
        ih.adc.nameid = suc::ADC1;
        ih.adc.mechanical_id = 0;

        ih.apodizer_w.nameid = suc::APODIZER_W;
        ih.apodizer_w.mechanical_id = 0;

        ih.cal_fiber_defocus_lamp.nameid = suc::CAL_FIBER_DEFOCUS_LAMP;
        ih.cal_fiber_defocus_lamp.mechanical_id = 0;

        ih.cal_fiber_dep.nameid = suc::CAL_FIBER_DEP;
        ih.cal_fiber_dep.mechanical_id = 0;
        
        ih.cal_fiber_focus_lamp.nameid = suc::CAL_FIBER_FOCUS_LAMP;
        ih.cal_fiber_focus_lamp.mechanical_id = 0;

        ih.cal_filter_dep.nameid = suc::CAL_FILTER_DEP;
        ih.cal_filter_dep.mechanical_id = 0;

        ih.cal_flat_field_lamp.nameid = suc::CAL_FF_LAMP;
        ih.cal_flat_field_lamp.mechanical_id = 0;

        ih.cal_mirror_dep.nameid = suc::CAL_MIRROR_DEP;
        ih.cal_mirror_dep.mechanical_id = 0;

        ih.coro_slit_w.nameid = suc::CORO_SLIT_W;
        ih.coro_slit_w.mechanical_id = 0;

        ih.db_filt_w.nameid = suc::DB_FILT_W;
        ih.db_filt_w.mechanical_id = 0;

        ih.derotator.nameid = suc::DEROT;
        ih.derotator.mechanical_id = 0;
        
        ih.inbeam_dep.nameid = suc::INBEAM_DEP;
        ih.inbeam_dep.mechanical_id = 0;

        ih.inbeam_tt.nameid = suc::INBEAM_TT;
        ih.inbeam_tt.mechanical_id = 0;

        ih.lyot_grism_w.nameid = suc::LYOT_GRISM_W;
        ih.lyot_grism_w.mechanical_id = 0;

        ih.nd_filt_w.nameid = suc::ND_FILT_W;
        ih.nd_filt_w.mechanical_id = 0;

        ih.pupil_lens_dep.nameid = suc::PUPIL_LENS_DEP;
        ih.pupil_lens_dep.mechanical_id = 0;

        ih.sci_filt_w1.nameid = suc::SCI_FILT_W1;
        ih.sci_filt_w1.mechanical_id = 0;
        
        ih.sci_filt_w2.nameid = suc::SCI_FILT_W2;
        ih.sci_filt_w2.mechanical_id = 0;
        
        ih.shutter.nameid = suc::SHUTTER;
        ih.shutter.mechanical_id = 0;
sharknirws2's avatar
sharknirws2 committed

        ih.adc_mode.nameid = suc::ADCMode;
        ih.drot_mode.nameid = suc::DROTMode;
        ih.mask_comb.nameid = suc::mask_comb;

        ih.temperature_start = ih.temperature_end = 0.0f;
    }

    ih.temperature_end = ih.temperature_start;
    ih.temperature_start = getMeanTemperature();
    const std::map<std::string, indi::IElement> & elementsA = sharknirTemperatureDetector.getElements();
    float valueA = 0.f;
    bool bValueA = false;
    if(elementsA.find("value") != elementsA.end())
    {
        valueA = elementsA.find("value")->second.get<float>();
        bValueA = true;
    }
    ih.temperature_start = valueA;


    if(m_pGetMotorStatus)
    {
        m_pGetMotorStatus(ih.apodizer_w);
        m_pGetMotorStatus(ih.coro_slit_w);
        m_pGetMotorStatus(ih.lyot_grism_w);
        m_pGetMotorStatus(ih.nd_filt_w);
        m_pGetMotorStatus(ih.db_filt_w);
        m_pGetMotorStatus(ih.sci_filt_w1);
        m_pGetMotorStatus(ih.sci_filt_w2);

        m_pGetMotorStatus(ih.inbeam_dep);
        m_pGetMotorStatus(ih.pupil_lens_dep);
        ih.pupil_lens_dep.status = ih.pupil_lens_dep.type == "IN";
        m_pGetMotorStatus(ih.shutter);
        ih.shutter.status = ih.shutter.type == "OUT";

        m_pGetMotorStatus(ih.inbeam_tt);

        m_pGetMotorStatus(ih.cal_fiber_dep);
        m_pGetMotorStatus(ih.cal_mirror_dep);
        ih.cal_mirror_dep.status = ih.cal_mirror_dep.type == "IN";
        m_pGetMotorStatus(ih.cal_filter_dep);

        m_pGetMotorStatus(ih.derotator);
        m_pGetMotorStatus(ih.adc);
sharknirws2's avatar
sharknirws2 committed

        m_pGetMotorStatus(ih.drot_mode);
        m_pGetMotorStatus(ih.adc_mode);
        m_pGetMotorStatus(ih.mask_comb);

    ih.cal_flat_field_lamp.status = m_obContext.flat_field_lamp == "ON";
    ih.cal_flat_field_lamp.type = m_obContext.flat_field_lamp;
    ih.cal_fiber_focus_lamp.status = m_obContext.focus_lamp == "ON";
    ih.cal_fiber_focus_lamp.type = m_obContext.focus_lamp;
    ih.cal_fiber_defocus_lamp.status = m_obContext.defocus_lamp == "ON";
    ih.cal_fiber_defocus_lamp.type = m_obContext.defocus_lamp;


    if(m_pGetRtcStatus)
    {
        for(std::map<std::string, std::string>::iterator itRtc = m_rtcKeywords.begin(); itRtc != m_rtcKeywords.end(); itRtc++)itRtc->second = m_pGetRtcStatus(itRtc->first);
    }

    m_bInstrumentSetupUpdated = true;
    U8_LLOG("");
float SeqDataMgr::getMeanTemperature()
{
    const std::map<std::string, indi::IElement> & elementsA = sharknirTemperatureDetector.getElements();
    float valueA = 0.f, valueB = 0.f;
    bool bValueA = false, bValueB = false;
    if(elementsA.find("value") != elementsA.end())
    {
        valueA = elementsA.find("value")->second.get<float>();
        bValueA = true;
    }
    const std::map<std::string, indi::IElement> & elementsB = sharknirTemperatureColdFinger.getElements();
    if(elementsB.find("value") != elementsB.end())
    {
        valueB = elementsB.find("value")->second.get<float>();
        bValueB = true;
    }

    float meanTemperature = 0.f;
    if(bValueA)meanTemperature += valueA;
    if(bValueB)meanTemperature += valueB;
    if(bValueA && bValueB)meanTemperature /= 2.f;

    return meanTemperature;
}