BmnMille.cxx

Go to the documentation of this file.

#include "BmnMille.h"
//___________________________________________________________________________
 
 
BmnMille::BmnMille(const Char_t* outFileName, Bool_t asBinary, Bool_t writeZero) :
myOutFile(outFileName, (asBinary ? (std::ios::binary | std::ios::out) : std::ios::out)),
myAsBinary(asBinary), myWriteZero(writeZero), myBufferPos(-1), myHasSpecial(kFALSE) {
    // Instead myBufferPos(-1), myHasSpecial(false) and the following two lines
    // we could call newSet() and kill()...
    myBufferInt[0] = 0;
    myBufferFloat[0] = 0.;
 
    if (!myOutFile.is_open()) {
        cerr << "Mille::Mille: Could not open " << outFileName
                << " as output file." << endl;
    }
}
 
//___________________________________________________________________________
 
BmnMille::~BmnMille() {
    myOutFile.close();
}
 
//___________________________________________________________________________
 
void BmnMille::mille(Int_t NLC, const Double_t* derLc,
        Int_t NGL, const Double_t* derGl, const Int_t* label,
        Double_t rMeas, Double_t sigma) {
    if (sigma <= 0.) return;
    if (myBufferPos == -1) this->newSet(); // start, e.g. new track
    if (!this->checkBufferSize(NLC, NGL)) return;
 
    // first store measurement
    ++myBufferPos;
    myBufferFloat[myBufferPos] = rMeas;
    myBufferInt [myBufferPos] = 0;
 
    // store local derivatives and local 'lables' 1,...,NLC
    for (Int_t i = 0; i < NLC; ++i) {
        if (derLc[i] || myWriteZero) { // by default store only non-zero derivatives
            ++myBufferPos;
            myBufferFloat[myBufferPos] = derLc[i]; // local derivatives
            myBufferInt [myBufferPos] = i + 1; // index of local parameter
        }
    }
 
    // store uncertainty of measurement in between locals and globals
    ++myBufferPos;
    myBufferFloat[myBufferPos] = sigma;
    myBufferInt [myBufferPos] = 0;
 
    // store global derivatives and their labels
    for (Int_t i = 0; i < NGL; ++i) {
        if (derGl[i] || myWriteZero) { // by default store only non-zero derivatives
            if ((label[i] > 0 || myWriteZero) && label[i] <= myMaxLabel) { // and for valid labels
                ++myBufferPos;
                myBufferFloat[myBufferPos] = derGl[i]; // global derivatives
                myBufferInt [myBufferPos] = label[i]; // index of global parameter
            } else {
                cerr << "Mille::mille: Invalid label " << label[i]
                        << " <= 0 or > " << myMaxLabel << endl;
            }
        }
    }
}
 
//___________________________________________________________________________
 
void BmnMille::special(Int_t nSpecial, const Double_t* floatings, const Int_t* integers) {
    if (nSpecial == 0) return;
    if (myBufferPos == -1) this->newSet(); // start, e.g. new track
    if (myHasSpecial) {
        cerr << "Mille::special: Special values already stored for this record."
                << endl;
        return;
    }
    if (!this->checkBufferSize(nSpecial, 0)) return;
    myHasSpecial = kTRUE; // after newSet() (Note: MILLSP sets to buffer position...)
 
    //  myBufferFloat[.]  | myBufferInt[.]
    // ------------------------------------
    //      0.0           |      0
    //  -float(nSpecial)  |      0
    //  The above indicates special data, following are nSpecial floating and nSpecial integer data.
 
    ++myBufferPos; // zero pair
    myBufferFloat[myBufferPos] = 0.;
    myBufferInt [myBufferPos] = 0;
 
    ++myBufferPos; // nSpecial and zero
    myBufferFloat[myBufferPos] = -nSpecial; // automatic conversion to float
    myBufferInt [myBufferPos] = 0;
 
    for (Int_t i = 0; i < nSpecial; ++i) {
        ++myBufferPos;
        myBufferFloat[myBufferPos] = floatings[i];
        myBufferInt [myBufferPos] = integers[i];
    }
}
 
//___________________________________________________________________________
 
void BmnMille::kill() {
    myBufferPos = -1;
}
 
//___________________________________________________________________________
 
void BmnMille::end() {
    if (myBufferPos > 0) { // only if anything stored...
        const Int_t numWordsToWrite = (myBufferPos + 1)*2;
 
        if (myAsBinary) {
            myOutFile.write(reinterpret_cast<const char*> (&numWordsToWrite),
                    sizeof (numWordsToWrite));
            myOutFile.write(reinterpret_cast<char*> (myBufferFloat),
                    (myBufferPos + 1) * sizeof (myBufferFloat[0]));
            myOutFile.write(reinterpret_cast<char*> (myBufferInt),
                    (myBufferPos + 1) * sizeof (myBufferInt[0]));
        } else {
            myOutFile << numWordsToWrite << "\n";
            for (Int_t i = 0; i < myBufferPos + 1; ++i) {
                myOutFile << myBufferFloat[i] << " ";
            }
            myOutFile << "\n";
 
            for (Int_t i = 0; i < myBufferPos + 1; ++i) {
                myOutFile << myBufferInt[i] << " ";
            }
            myOutFile << "\n";
        }
    }
    myBufferPos = -1; // reset buffer for next set of derivatives
}
 
//___________________________________________________________________________
 
void BmnMille::newSet() {
    myBufferPos = 0;
    myHasSpecial = kFALSE;
    myBufferFloat[0] = 0.0;
    myBufferInt [0] = 0; // position 0 used as error counter
}
 
//___________________________________________________________________________
 
bool BmnMille::checkBufferSize(Int_t nLocal, Int_t nGlobal) {
    if (myBufferPos + nLocal + nGlobal + 2 >= myBufferSize) {
        ++(myBufferInt[0]); // increase error count
        std::cerr << "Mille::checkBufferSize: Buffer too short ("
                << myBufferSize << "),"
                << "\n need space for nLocal (" << nLocal << ")"
                << "/nGlobal (" << nGlobal << ") local/global derivatives, "
                << myBufferPos + 1 << " already stored!"
                << std::endl;
        return kFALSE;
    } else {
        return kTRUE;
    }
}