ROOT logo
//*-- AUTHOR : Ilse Koenig
//*-- Modified : 17/01/2002 by Ilse Koenig
//*-- Modified : 17/02/2000 by J. Kempter
//*-- Modified : 24/08/99 by R. Holzmann
//*-- Modified : 29/07/99 by Ilse Koenig

//_HADES_CLASS_DESCRIPTION 
///////////////////////////////////////////////////////////////////////////////
//
// HMdcCalibrater1
//
// This transformation class calculates the drift time information in all fired
// cells using parameters from the parameter containers MdcCalParRaw for the
// calibration parameters and from MdcLookupGeom to map the layer number and
// cell number on Cal1 level to the motherboard number and TDC channel number
// on Raw level.
// The drift times are randomized within one bin of TDC resolution.
//
// The constructor gives different options how to fill HMdcCal1 level:
// HMdcCalibrater1(name,title,option input, otption timecut, option embedding )
//    option input   =  1 No Start and Cal (default)
//                      2 Start and Cal
//                      3 No Start and no Cal
//    option timecut =  1 time cuts switched on
//                      0 time cuts switched off
//    option embedding = 0 no embedding
//                     = 1 embedding
// Start means that the startime from the Startdetector will be used to correct.
// Cal means real calibration with parameters from HMdcCalParRaw
// If no Cal (3)is selected no input from HMdcCalParRaw is needed
// and the TDC slope parameter will be always 1.The offset is set to 2048
// which means that the HMdcCal1 level will be a reversed copy of HMdcRaw.
///////////////////////////////////////////////////////////////////////////////
using namespace std;
#include "hmdccalibrater1.h"
#include "hmdcdef.h"
#include "hdebug.h"
#include "hades.h"
#include "hiterator.h"
#include "hruntimedb.h"
#include "hcategorymanager.h"
#include "hspectrometer.h"
#include "hdetector.h"
#include "hmdcdetector.h"
#include "hevent.h"
#include "hrecevent.h"
#include "hcategory.h"
#include "hlocation.h"
#include "hmdcraw.h"
#include "hmdccal1.h"
#include "hmdccal1sim.h"
#include "hmdccalparraw.h"
#include "hmdctimecut.h"
#include "hmdccutstat.h"
#include "hmdcwirestat.h"
#include "hmdclookupgeom.h"
#include "hstart2hit.h"

#include <iostream> 
#include <iomanip>
#include <stdlib.h>

Float_t HMdcCalibrater1::globalOffset[4]={0,0,0,0};
Float_t HMdcCalibrater1::globalSecOffset[6][4]={{0,0,0,0},
                                                {0,0,0,0},
                                                {0,0,0,0},
                                                {0,0,0,0},
                                                {0,0,0,0},
                                                {0,0,0,0}};
Float_t HMdcCalibrater1::globalSlope=1;
Int_t HMdcCalibrater1::countNrWiresPerMod[6][4]=
{
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0}};
Int_t HMdcCalibrater1::countNrWiresPerModCal[6][4]=
{
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0}};
Int_t HMdcCalibrater1::countNrFlashWiresPerMod[6][4]=
{
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0}};
Int_t HMdcCalibrater1::countNDeltaElWiresPerMod[6][4]=
{
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0},
    {0,0,0,0}};
    
Bool_t HMdcCalibrater1::useWireStat=kFALSE;

ClassImp(HMdcCalibrater1)

HMdcCalibrater1::HMdcCalibrater1(void) {
  // Default constructor .
  initParameters();
}
HMdcCalibrater1::HMdcCalibrater1(const Text_t* name,const Text_t* title,Int_t vers,Int_t cut,Int_t merge)
                 :  HReconstructor(name,title) {
  // Constructor calls the constructor of class HReconstructor with the name
  // and the title as arguments.
  initParameters();
  switchArguments(vers,cut,merge);
}

HMdcCalibrater1::~HMdcCalibrater1(void) {
  // destructor deletes the iterator
  if (iter) delete iter;
  iter=0;
  if (iterstart) delete iterstart;
  iterstart=0;
  if(cutStat)HMdcCutStat::deleteHMdcCutStat();
}
void HMdcCalibrater1::switchArguments(Int_t vers,Int_t cut,Int_t merge)
{
    if(cut==0 || cut==1)
    {
	if(cut==0) setTimeCut=kFALSE;
	if(cut==1) setTimeCut=kTRUE;
    }
    else
    {
	Error("HMdcCalibrater1:switchArguments(Int_t vers,Int_t cut,Int_t merge):"
	      ,"\n unknown argument cut: use \n 0 for no time cuts \n 1 for time cuts");
	exit(1);
    }
    if(vers==1 || vers==2 || vers==3)
    {
	if(vers==1)
	{
	    NoStartandCal=kTRUE;
	    StartandCal=kFALSE;
	    NoStartandNoCal=kFALSE;
	}
	if(vers==2)
	{
	    StartandCal=kTRUE;
	    NoStartandCal=kFALSE;
	    NoStartandNoCal=kFALSE;
	}
	if(vers==3)
	{
	    NoStartandNoCal=kTRUE;
	    StartandCal=kFALSE;
	    NoStartandCal=kFALSE;
	}
    }
    else
    {
	Error("HMdcCalibrater1:switchArguments(Int_t vers,Int_t cut,Int_t merge):"
	      ,"\n unknown argument vers: use \n 1 for nostartandcal,\n 2 for startandcal,\n 3 for nostartandnocal,\n ");
	exit(1);
    }
    if(merge==0 || merge==1)
    {
         embedding=merge;
    }
    else
    {
	Error("HMdcCalibrater1:switchArguments(Int_t vers,Int_t cut,Int_t merge):"
	      ,"\n unknown argument merge: use \n 0 for normal mode,\n 1 for embedding!\n ");
	exit(1);
    }
}
void HMdcCalibrater1::initParameters()
{
    rawCat=0;
    calCat=0;
    raw=0;
    cal=0;
    startHitCat=0;
    iter=0;
    iterstart=0;
    calparraw=0;
    wireStat=0;
    timecut=0;
    cutStat=0;
    lookup=0;
    NoStartandNoCal=kFALSE;
    StartandCal=kFALSE;
    NoStartandCal=kTRUE;
    setTimeCut=kFALSE;
    hasPrinted=kFALSE;
    embedding=0;
    cutthreshold=150;
    useMultCut=kFALSE;
    useMultCutTot=kFALSE;
    doSkipMultCut=kTRUE;
    doprint=kFALSE;
    skipCal=kTRUE;
    ctEvent=0;
    ctEventSkip=0;
    
    flashTotCut    =  30.; 
    flashT1Cut[0]  = -5.; //90.;
    flashT1Cut[1]  = -5.; //100.;
    flashT1Cut[2]  = -5.; //160.;
    flashT1Cut[3]  = -5.; //180.;
    flashMultCut   = 0; 
    skipFlashEvent = flashMultCut>10;
    timeT1Cut      = -10.;
    deltaElMultCut = 0;
    skipDeltaElEvt = deltaElMultCut > 10;
}
void HMdcCalibrater1::setParContainers() {
  // creates the parameter containers MdcCalParRaw and MdcLookupGeom if they do not
  // exist and adds them to the list of parameter containers in the rumtime
  // database
    lookup=(HMdcLookupGeom*)(((HRuntimeDb*)(gHades->getRuntimeDb()))->getContainer("MdcLookupGeom"));
    if(setTimeCut) {
	timecut=(HMdcTimeCut*)(((HRuntimeDb*)(gHades->getRuntimeDb()))->getContainer("MdcTimeCut"));
	timecut->setIsUsed(kTRUE);
    }
    if(setTimeCut==kTRUE)
    {
	cutStat=(HMdcCutStat*)HMdcCutStat::getObject();
	if(!cutStat)
	{
	    Error("HMdcCalibrater1:setParContainers()","RETRIEVED 0 POINTER FOR HMDCCUTSTAT!");
	    exit(1);
	}
    }
    if(StartandCal||NoStartandCal){
	calparraw=(HMdcCalParRaw*)(((HRuntimeDb*)(gHades->getRuntimeDb()))->getContainer("MdcCalParRaw"));
    }
    if(useWireStat){
       wireStat = (HMdcWireStat*)(((HRuntimeDb*)(gHades->getRuntimeDb()))->getContainer("MdcWireStat"));

    } else {
       wireStat = 0;
    }

}
Bool_t HMdcCalibrater1::init(void) {
  // creates the MdcRaw  and MdcCal1 categories and adds them to the current
  // event
  // creates an iterator which loops over all fired cells
  // calls the function setParContainers()
  if(gHades->getEmbeddingMode()>0)
  {
      if(embedding==0)
      {
	  Warning("HMdcCalibrater1::init()","global embedding mode >0 detected, but local running embedding==0, switch to common mode!");
	  embedding=1;
      }
  }
  setParContainers();
  rawCat=(HCategory*)(((HEvent*)(gHades->getCurrentEvent()))->getCategory(catMdcRaw));
  if (!rawCat) {
      Error("HMdcCalibrater1:init()","HMdcRaw Category not available!");
      exit(1);
  }
  calCat=(HCategory*)(((HEvent*)(gHades->getCurrentEvent()))->getCategory(catMdcCal1));
  if (!calCat) {
      if(embedding==0)calCat=(HCategory*)((HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"))->buildCategory(catMdcCal1));
      if(embedding==1)
      {
          HMdcDetector* mymdc=(HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"));
	  calCat=(HCategory*)(((HMdcDetector*)mymdc)->buildMatrixCategory("HMdcCal1Sim",0.5F));
      }
      if (!calCat) return kFALSE;
      else ((HEvent*)(gHades->getCurrentEvent()))->addCategory(catMdcCal1,calCat,"Mdc");
  }
  if(StartandCal){
      startHitCat=(HCategory*)(((HEvent*)(gHades->getCurrentEvent()))->getCategory(catStart2Hit));
      if (!startHitCat) {
	  Error("HMdcCalibrater1:init()","Start2Hit Category not available,\n but Option StartAndCal used!");
          exit(1);
      }
  }

  iter=(HIterator *)((HCategory*)rawCat)->MakeIterator("native");
  loc.set(4,0,0,0,0);

  if(StartandCal){
      iterstart=(HIterator *)((HCategory*)startHitCat)->MakeIterator("native");
  }
  if(!hasPrinted)printStatus();
  fActive=kTRUE;
  return kTRUE;
}
void HMdcCalibrater1::printStatus()
{
    Int_t ModeFlagCal1,TimeCutFlagCal1;
    ModeFlagCal1=TimeCutFlagCal1=-99;
    if(NoStartandCal)  ModeFlagCal1   =1;
    if(StartandCal)    ModeFlagCal1   =2;
    if(NoStartandNoCal)ModeFlagCal1   =3;
    if(!setTimeCut)    TimeCutFlagCal1=0;
    if(setTimeCut)     TimeCutFlagCal1=1;

    // prints the parameters to the screen
    SEPERATOR_msg("-",60);
    INFO_msg(10,HMessageMgr::DET_MDC,"HMdcCalibrater1Setup:");
    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
			   ,"ModeFlagCal1    =  %i :  1 = NoStartandCal, 2 = StartandCal, 3 = NoStartandNoCal",ModeFlagCal1);
    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
			   ,"TimeCutFlagCal1 =  %i :  0 = noTimeCut    , 1 = TimeCut",TimeCutFlagCal1);
    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
			   ,"Embedding       =  %i :  0 = noEmbedding  , 1 = Embedding",embedding);
    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
			   ,"MultCut         =  %i :  0 = noCut  , 1 = Cut",(Int_t)useMultCut);
    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
			   ,"Cut Threshold   =  %i ",cutthreshold);
    SEPERATOR_msg("-",60);
    hasPrinted=kTRUE;
}

Float_t HMdcCalibrater1::getstarttime(){
  // Need some work for multiple hists in start detector
  // Better select multiplicity 1 in start.
  HStart2Hit* starthit=0;
  Float_t starttime=0;
  if(startHitCat->getEntries()<1) return starttime;
  starthit=HCategoryManager::getObject(starthit,startHitCat,0,kTRUE); // silent
  if(!starthit) {
      return starttime;
  }
  starttime = -starthit->getTime();

  return starttime;
}
Bool_t HMdcCalibrater1::translateAddress(Int_t* mbo,Int_t* ch)
{
    raw->getAddress(loc[0],loc[1],*mbo,*ch);
    if (loc[0]<0 || loc[1]<0) return kFALSE;
    HMdcLookupMoth& lookGMoth = (*lookup)[loc[0]][loc[1]][*mbo];
    if(&lookGMoth == NULL || lookGMoth.getSize() == 0) return kFALSE;
    HMdcLookupChan& chan=(*lookup)[loc[0]][loc[1]][*mbo][*ch];
    loc[2]=chan.getNLayer();
    loc[3]=chan.getNCell();
    return kTRUE;
}
Bool_t HMdcCalibrater1::testTimeCuts(Float_t testTime1,Float_t testTime2){
  // tests if the measured time will pass the time cuts
  //
    if(useWireStat&&wireStat){
	if(wireStat->getStatus(loc[0],loc[1],loc[2],loc[3]) < 0) return kFALSE;
    }

    if(!timecut) return kTRUE;

    if(setTimeCut==kTRUE)
    {
	if(timecut->cutTime1(loc[0],loc[1],testTime1))
	{cuts[0]=0;}else{cuts[0]=1;}

	if(timecut->cutTime2(loc[0],loc[1],testTime2))
	{cuts[1]=0;}else{cuts[1]=1;}

	if(timecut->cutTimesDif(loc[0],loc[1],testTime1,testTime2))
	{cuts[2]=0;}else{cuts[2]=1;};

        if(countNrWiresPerMod[(Int_t)loc[0]][(Int_t)loc[1]]>3)
	{cuts[3]=0;}else{cuts[3]=1;};

	if(timecut->cutBump    (loc[0],loc[1],testTime1,testTime2-testTime1))
	{cuts[4]=0;}else{cuts[4]=1;};
                                                            //t1    t2      tot     bump    wire
        cutStat->setCal1StatCut((Int_t)loc[0],(Int_t)loc[1],cuts[0],cuts[1],cuts[2],cuts[4],cuts[3]);
    }

    if(timecut->cutTime1   (loc[0],loc[1],testTime1)&&
       timecut->cutTime2   (loc[0],loc[1],testTime2)&&
       timecut->cutBump    (loc[0],loc[1],testTime1,testTime2-testTime1)&&
       timecut->cutTimesDif(loc[0],loc[1],testTime1,testTime2))
    {
	return kTRUE;
    }
    else
    {
	return kFALSE;
    }
}
void HMdcCalibrater1::countWiresPerMod()
{
  // counts the number of fired wires per mod
  //
    raw=0;
    iter->Reset();
    while ((raw=(HMdcRaw *)iter->Next())!=0)
    {
	raw->getAddress(loc[0],loc[1],loc[2],loc[3]);
        countNrWiresPerMod[(Int_t)loc[0]][(Int_t)loc[1]]++;
    }
}
void HMdcCalibrater1::fillCal1(Float_t testTime1,Float_t testTime2,Int_t nHits)
{
  // fill time1,time2 and nHits to Cal1
  //
    if(embedding==0)
    {
	cal=(HMdcCal1 *)calCat->getSlot(loc);
	cal=new(cal) HMdcCal1;
    }
    else
    {
      	cal=(HMdcCal1Sim *)calCat->getSlot(loc);
	cal=new(cal) HMdcCal1Sim;
    }
    if(cal)
    {
	cal->setNHits(nHits);
	cal->setAddress(loc[0],loc[1],loc[2],loc[3]);

	countNrWiresPerModCal[loc[0]][loc[1]]++; // counting per module

	if(StartandCal||NoStartandCal)
	{
	    cal->setTime1(testTime1);
	    cal->setTime2(testTime2);
	}
	if(NoStartandNoCal)
	{
	    cal->setTime1(testTime1);

	    if (abs(nHits)>=2)
	    {
		cal->setTime2(testTime2);
	    }
	}
    }
    else
    {
	Warning("HMdcCalibrater1::fillCal1()","NO SLOT AVAILABLE IN catMdcCal1 FOR SECTOR %i . \n SIZE OF CATEGORY IS %i .",loc[0],calCat->getEntries());
    }
}
void HMdcCalibrater1::calcTimes(Float_t* testTime1,Float_t* testTime2,Float_t starttime,Int_t nHits,HMdcCalParTdc* tdc)
{
  // calc testtime1,testtime2
  //
    Float_t offset; 
    Float_t slope;

    if(tdc){
	offset = tdc->getOffset();
	slope  = tdc->getSlope();
    } else {
	offset = 0;
        slope  = 1;
    }

    Int_t t1       = raw->getTime(1);
    Int_t t2       = raw->getTime(2);
    Float_t rnd1   = gRandom->Rndm() - 0.5F;
    Float_t rnd2   = gRandom->Rndm() - 0.5F;


    if(NoStartandCal)
    {
	*testTime1 = (offset - ((t1 + rnd1) * slope)) - globalSecOffset[loc[0]][loc[1]];
	if (abs(nHits) >= 2) {
	    *testTime2 = (offset - ((t2 + rnd2) * slope)) - globalSecOffset[loc[0]][loc[1]];
	}
    }
    if(StartandCal)
    {
	*testTime1 = (offset - ((t1 + rnd1) * slope) + starttime) - globalSecOffset[loc[0]][loc[1]];
	if (abs(nHits) >= 2) {
	    *testTime2 = (offset - ((t2 + rnd2) * slope) + starttime) - globalSecOffset[loc[0]][loc[1]];
	}
    }
    if(NoStartandNoCal)
    {
	switch (t1){
	case 0:    *testTime1 =- 998.;
	break;
	case -999: *testTime1 =- 999.;
	break;
	default :
	    *testTime1 = (2048 - (t1 + rnd1)) * globalSlope - globalSecOffset[loc[0]][loc[1]];
	    break;
	}
	if (abs(nHits) >= 2){
	    switch(t2){
	    case 0:    *testTime2 =- 998.;
	    break;
	    case -999: *testTime2 =- 999.;
	    break;
	    default:   *testTime2 = (2048 - (t2 + rnd2)) * globalSlope - globalSecOffset[loc[0]][loc[1]] ;
	    break;
	    }
	}
    }
}
Int_t HMdcCalibrater1::execute(void) {

    // calibrates all fired cells
    // For time1 or time2 equal -999 in raw the times in cal1 are set to -999.
    // For time1 or time2 equal 0 in raw the times in cal1 are set to -998.
    // This differnt value is used to distinguish between not filled times and times equal 0.
    // The calibration parameters are taken from HMdcCalParRaw container.The
    // Calibration is only performed if Offset and Slope are not 0.
    // Only time1 and time2 are calibrated.
    Bool_t debug = kFALSE;

    if(skipCal&&gHades->getCurrentEvent()->getHeader()->getId()==9) {
	return 0;
    }

    //######################### count wires per mod #########################
    
    initCounters();    // set conters to 0
    initCountersCal(); // set conters to 0
    countWiresPerMod();// check for less than 4 wires per module
    //#######################################################################
    ctEvent++;

    raw=0;
    cal=0;
    Float_t testTime1=0;
    Float_t testTime2=0;
    Float_t starttime=0;
    Int_t mbo, ch;
    iter->Reset();
    if(StartandCal)starttime=getstarttime();
    while ((raw=(HMdcRaw *)iter->Next())!=0)
    {
	if(!translateAddress(&mbo,&ch))continue;
	if (loc[3]>=0)
	{
	    const Int_t nHits=raw->getNHits();
	    HMdcCalParTdc* tdc=0;
	    if(calparraw)
	    {
		tdc=&(*calparraw)[loc[0]][loc[1]][mbo][ch];
	    }
	    calcTimes(&testTime1,&testTime2,starttime,nHits,tdc);

            // "Flash" wire check
            if(fabs(testTime2-testTime1)<flashTotCut && testTime1<flashT1Cut[loc[1]]) { // "Flash" wire check
              countNrFlashWiresPerMod[loc[0]][loc[1]]++;
              raw->setFlashWire();
            } else if(testTime1<timeT1Cut) {                                            // "DeltaElectron" wires check
              countNDeltaElWiresPerMod[loc[0]][loc[1]]++; 
              raw->setDeltaElectWire();
            }
            
	    // if time cuts are used
	    if(testTimeCuts(testTime1,testTime2)) // test timecuts + wirestat (if enabled)
	    {
		fillCal1(testTime1,testTime2,nHits);
	    }
	}
	else if (debug)
	{
	    gHades->getMsg()->debug(10,HMessageMgr::DET_MDC,GetName()
				    ,"lookup s=%i m=%i mbo=%2i chan=%2i not connected\n", loc[0],loc[1],mbo,ch);
	}
    }
    if(useMultCut)
    {
	if(doMultCut())
	{
	    ctEventSkip++;

	    if(doprint)
	    {
		printWires();
	    }

	    if(doSkipMultCut) return kSkipEvent;
	}
    }
    
    if((skipFlashEvent && doFlashCut()) || (skipDeltaElEvt && doDeltaElCut()))
    {
        if(doprint) printWires();
        return kSkipEvent;
    }

    return 0;
}

void HMdcCalibrater1::printWires()
{
    cout<<"HMdcCalibrater1-----------------------------"<<endl;
    if(useMultCutTot) cout<<"MultiplicityCutTot-----------------------------"<<endl;
    else              cout<<"MultiplicityCut-----------------------------"<<endl;
    cout<<"EVT="<<setw(5)<<gHades->getEventCounter()
	<<" ("<<setw(5)<<ctEventSkip<<"/"<<setw(5)<<ctEvent<<") : "<<setw(8)<<(ctEventSkip>0? (ctEventSkip/(Float_t)ctEvent)*100.:0)<<"%"<<endl;
    cout<<"Number of wires in Cal1="<<calCat->getEntries()<<endl;
    cout<<"Triggered by  number of wires in one module > "<<cutthreshold<<endl;
    
    if(skipFlashEvent) cout<<"Detected Flash events are skipped! "<<endl;
    else               cout<<"Detected Flash events are NOT skipped! "<<endl;
    for(Int_t i=0;i<6;i++){
	printf("s %i : %4i %4i %4i %4i Segments %4i %4i\n"
               ,i
	       ,countNrFlashWiresPerMod[i][0]
               ,countNrFlashWiresPerMod[i][1]
	       ,countNrFlashWiresPerMod[i][2]
               ,countNrFlashWiresPerMod[i][3]
               ,countNrFlashWiresPerMod[i][0]+countNrFlashWiresPerMod[i][1]
               ,countNrFlashWiresPerMod[i][2]+countNrFlashWiresPerMod[i][3]);
    }
    if(skipDeltaElEvt) cout<<"Detected DeltaElect events are skipped! "<<endl;
    else               cout<<"Detected DeltaElect events are NOT skipped! "<<endl;
    for(Int_t i=0;i<6;i++){
	printf("s %i : %4i %4i %4i %4i Segments %4i %4i\n"
               ,i
	       ,countNDeltaElWiresPerMod[i][0]
               ,countNDeltaElWiresPerMod[i][1]
	       ,countNDeltaElWiresPerMod[i][2]
               ,countNDeltaElWiresPerMod[i][3]
               ,countNDeltaElWiresPerMod[i][0]+countNDeltaElWiresPerMod[i][1]
               ,countNDeltaElWiresPerMod[i][2]+countNDeltaElWiresPerMod[i][3]);
    }
    cout<<"Number of wires after time cuts:"<<endl;
    for(Int_t i=0;i<6;i++){
	printf("s %i : %i %i %i %i\n"
               ,i
	       ,countNrWiresPerModCal[i][0]
	       ,countNrWiresPerModCal[i][1]
	       ,countNrWiresPerModCal[i][2]
	       ,countNrWiresPerModCal[i][3]);
    }
    /*
    if(ctEvent>=1000){

	ctEventSkip = 0;
	ctEvent     = 0;
        cout<<"Event counter reset!"<<endl;
    }*/
    cout<<"-------------------------------------------"<<endl;
}

 hmdccalibrater1.cc:1
 hmdccalibrater1.cc:2
 hmdccalibrater1.cc:3
 hmdccalibrater1.cc:4
 hmdccalibrater1.cc:5
 hmdccalibrater1.cc:6
 hmdccalibrater1.cc:7
 hmdccalibrater1.cc:8
 hmdccalibrater1.cc:9
 hmdccalibrater1.cc:10
 hmdccalibrater1.cc:11
 hmdccalibrater1.cc:12
 hmdccalibrater1.cc:13
 hmdccalibrater1.cc:14
 hmdccalibrater1.cc:15
 hmdccalibrater1.cc:16
 hmdccalibrater1.cc:17
 hmdccalibrater1.cc:18
 hmdccalibrater1.cc:19
 hmdccalibrater1.cc:20
 hmdccalibrater1.cc:21
 hmdccalibrater1.cc:22
 hmdccalibrater1.cc:23
 hmdccalibrater1.cc:24
 hmdccalibrater1.cc:25
 hmdccalibrater1.cc:26
 hmdccalibrater1.cc:27
 hmdccalibrater1.cc:28
 hmdccalibrater1.cc:29
 hmdccalibrater1.cc:30
 hmdccalibrater1.cc:31
 hmdccalibrater1.cc:32
 hmdccalibrater1.cc:33
 hmdccalibrater1.cc:34
 hmdccalibrater1.cc:35
 hmdccalibrater1.cc:36
 hmdccalibrater1.cc:37
 hmdccalibrater1.cc:38
 hmdccalibrater1.cc:39
 hmdccalibrater1.cc:40
 hmdccalibrater1.cc:41
 hmdccalibrater1.cc:42
 hmdccalibrater1.cc:43
 hmdccalibrater1.cc:44
 hmdccalibrater1.cc:45
 hmdccalibrater1.cc:46
 hmdccalibrater1.cc:47
 hmdccalibrater1.cc:48
 hmdccalibrater1.cc:49
 hmdccalibrater1.cc:50
 hmdccalibrater1.cc:51
 hmdccalibrater1.cc:52
 hmdccalibrater1.cc:53
 hmdccalibrater1.cc:54
 hmdccalibrater1.cc:55
 hmdccalibrater1.cc:56
 hmdccalibrater1.cc:57
 hmdccalibrater1.cc:58
 hmdccalibrater1.cc:59
 hmdccalibrater1.cc:60
 hmdccalibrater1.cc:61
 hmdccalibrater1.cc:62
 hmdccalibrater1.cc:63
 hmdccalibrater1.cc:64
 hmdccalibrater1.cc:65
 hmdccalibrater1.cc:66
 hmdccalibrater1.cc:67
 hmdccalibrater1.cc:68
 hmdccalibrater1.cc:69
 hmdccalibrater1.cc:70
 hmdccalibrater1.cc:71
 hmdccalibrater1.cc:72
 hmdccalibrater1.cc:73
 hmdccalibrater1.cc:74
 hmdccalibrater1.cc:75
 hmdccalibrater1.cc:76
 hmdccalibrater1.cc:77
 hmdccalibrater1.cc:78
 hmdccalibrater1.cc:79
 hmdccalibrater1.cc:80
 hmdccalibrater1.cc:81
 hmdccalibrater1.cc:82
 hmdccalibrater1.cc:83
 hmdccalibrater1.cc:84
 hmdccalibrater1.cc:85
 hmdccalibrater1.cc:86
 hmdccalibrater1.cc:87
 hmdccalibrater1.cc:88
 hmdccalibrater1.cc:89
 hmdccalibrater1.cc:90
 hmdccalibrater1.cc:91
 hmdccalibrater1.cc:92
 hmdccalibrater1.cc:93
 hmdccalibrater1.cc:94
 hmdccalibrater1.cc:95
 hmdccalibrater1.cc:96
 hmdccalibrater1.cc:97
 hmdccalibrater1.cc:98
 hmdccalibrater1.cc:99
 hmdccalibrater1.cc:100
 hmdccalibrater1.cc:101
 hmdccalibrater1.cc:102
 hmdccalibrater1.cc:103
 hmdccalibrater1.cc:104
 hmdccalibrater1.cc:105
 hmdccalibrater1.cc:106
 hmdccalibrater1.cc:107
 hmdccalibrater1.cc:108
 hmdccalibrater1.cc:109
 hmdccalibrater1.cc:110
 hmdccalibrater1.cc:111
 hmdccalibrater1.cc:112
 hmdccalibrater1.cc:113
 hmdccalibrater1.cc:114
 hmdccalibrater1.cc:115
 hmdccalibrater1.cc:116
 hmdccalibrater1.cc:117
 hmdccalibrater1.cc:118
 hmdccalibrater1.cc:119
 hmdccalibrater1.cc:120
 hmdccalibrater1.cc:121
 hmdccalibrater1.cc:122
 hmdccalibrater1.cc:123
 hmdccalibrater1.cc:124
 hmdccalibrater1.cc:125
 hmdccalibrater1.cc:126
 hmdccalibrater1.cc:127
 hmdccalibrater1.cc:128
 hmdccalibrater1.cc:129
 hmdccalibrater1.cc:130
 hmdccalibrater1.cc:131
 hmdccalibrater1.cc:132
 hmdccalibrater1.cc:133
 hmdccalibrater1.cc:134
 hmdccalibrater1.cc:135
 hmdccalibrater1.cc:136
 hmdccalibrater1.cc:137
 hmdccalibrater1.cc:138
 hmdccalibrater1.cc:139
 hmdccalibrater1.cc:140
 hmdccalibrater1.cc:141
 hmdccalibrater1.cc:142
 hmdccalibrater1.cc:143
 hmdccalibrater1.cc:144
 hmdccalibrater1.cc:145
 hmdccalibrater1.cc:146
 hmdccalibrater1.cc:147
 hmdccalibrater1.cc:148
 hmdccalibrater1.cc:149
 hmdccalibrater1.cc:150
 hmdccalibrater1.cc:151
 hmdccalibrater1.cc:152
 hmdccalibrater1.cc:153
 hmdccalibrater1.cc:154
 hmdccalibrater1.cc:155
 hmdccalibrater1.cc:156
 hmdccalibrater1.cc:157
 hmdccalibrater1.cc:158
 hmdccalibrater1.cc:159
 hmdccalibrater1.cc:160
 hmdccalibrater1.cc:161
 hmdccalibrater1.cc:162
 hmdccalibrater1.cc:163
 hmdccalibrater1.cc:164
 hmdccalibrater1.cc:165
 hmdccalibrater1.cc:166
 hmdccalibrater1.cc:167
 hmdccalibrater1.cc:168
 hmdccalibrater1.cc:169
 hmdccalibrater1.cc:170
 hmdccalibrater1.cc:171
 hmdccalibrater1.cc:172
 hmdccalibrater1.cc:173
 hmdccalibrater1.cc:174
 hmdccalibrater1.cc:175
 hmdccalibrater1.cc:176
 hmdccalibrater1.cc:177
 hmdccalibrater1.cc:178
 hmdccalibrater1.cc:179
 hmdccalibrater1.cc:180
 hmdccalibrater1.cc:181
 hmdccalibrater1.cc:182
 hmdccalibrater1.cc:183
 hmdccalibrater1.cc:184
 hmdccalibrater1.cc:185
 hmdccalibrater1.cc:186
 hmdccalibrater1.cc:187
 hmdccalibrater1.cc:188
 hmdccalibrater1.cc:189
 hmdccalibrater1.cc:190
 hmdccalibrater1.cc:191
 hmdccalibrater1.cc:192
 hmdccalibrater1.cc:193
 hmdccalibrater1.cc:194
 hmdccalibrater1.cc:195
 hmdccalibrater1.cc:196
 hmdccalibrater1.cc:197
 hmdccalibrater1.cc:198
 hmdccalibrater1.cc:199
 hmdccalibrater1.cc:200
 hmdccalibrater1.cc:201
 hmdccalibrater1.cc:202
 hmdccalibrater1.cc:203
 hmdccalibrater1.cc:204
 hmdccalibrater1.cc:205
 hmdccalibrater1.cc:206
 hmdccalibrater1.cc:207
 hmdccalibrater1.cc:208
 hmdccalibrater1.cc:209
 hmdccalibrater1.cc:210
 hmdccalibrater1.cc:211
 hmdccalibrater1.cc:212
 hmdccalibrater1.cc:213
 hmdccalibrater1.cc:214
 hmdccalibrater1.cc:215
 hmdccalibrater1.cc:216
 hmdccalibrater1.cc:217
 hmdccalibrater1.cc:218
 hmdccalibrater1.cc:219
 hmdccalibrater1.cc:220
 hmdccalibrater1.cc:221
 hmdccalibrater1.cc:222
 hmdccalibrater1.cc:223
 hmdccalibrater1.cc:224
 hmdccalibrater1.cc:225
 hmdccalibrater1.cc:226
 hmdccalibrater1.cc:227
 hmdccalibrater1.cc:228
 hmdccalibrater1.cc:229
 hmdccalibrater1.cc:230
 hmdccalibrater1.cc:231
 hmdccalibrater1.cc:232
 hmdccalibrater1.cc:233
 hmdccalibrater1.cc:234
 hmdccalibrater1.cc:235
 hmdccalibrater1.cc:236
 hmdccalibrater1.cc:237
 hmdccalibrater1.cc:238
 hmdccalibrater1.cc:239
 hmdccalibrater1.cc:240
 hmdccalibrater1.cc:241
 hmdccalibrater1.cc:242
 hmdccalibrater1.cc:243
 hmdccalibrater1.cc:244
 hmdccalibrater1.cc:245
 hmdccalibrater1.cc:246
 hmdccalibrater1.cc:247
 hmdccalibrater1.cc:248
 hmdccalibrater1.cc:249
 hmdccalibrater1.cc:250
 hmdccalibrater1.cc:251
 hmdccalibrater1.cc:252
 hmdccalibrater1.cc:253
 hmdccalibrater1.cc:254
 hmdccalibrater1.cc:255
 hmdccalibrater1.cc:256
 hmdccalibrater1.cc:257
 hmdccalibrater1.cc:258
 hmdccalibrater1.cc:259
 hmdccalibrater1.cc:260
 hmdccalibrater1.cc:261
 hmdccalibrater1.cc:262
 hmdccalibrater1.cc:263
 hmdccalibrater1.cc:264
 hmdccalibrater1.cc:265
 hmdccalibrater1.cc:266
 hmdccalibrater1.cc:267
 hmdccalibrater1.cc:268
 hmdccalibrater1.cc:269
 hmdccalibrater1.cc:270
 hmdccalibrater1.cc:271
 hmdccalibrater1.cc:272
 hmdccalibrater1.cc:273
 hmdccalibrater1.cc:274
 hmdccalibrater1.cc:275
 hmdccalibrater1.cc:276
 hmdccalibrater1.cc:277
 hmdccalibrater1.cc:278
 hmdccalibrater1.cc:279
 hmdccalibrater1.cc:280
 hmdccalibrater1.cc:281
 hmdccalibrater1.cc:282
 hmdccalibrater1.cc:283
 hmdccalibrater1.cc:284
 hmdccalibrater1.cc:285
 hmdccalibrater1.cc:286
 hmdccalibrater1.cc:287
 hmdccalibrater1.cc:288
 hmdccalibrater1.cc:289
 hmdccalibrater1.cc:290
 hmdccalibrater1.cc:291
 hmdccalibrater1.cc:292
 hmdccalibrater1.cc:293
 hmdccalibrater1.cc:294
 hmdccalibrater1.cc:295
 hmdccalibrater1.cc:296
 hmdccalibrater1.cc:297
 hmdccalibrater1.cc:298
 hmdccalibrater1.cc:299
 hmdccalibrater1.cc:300
 hmdccalibrater1.cc:301
 hmdccalibrater1.cc:302
 hmdccalibrater1.cc:303
 hmdccalibrater1.cc:304
 hmdccalibrater1.cc:305
 hmdccalibrater1.cc:306
 hmdccalibrater1.cc:307
 hmdccalibrater1.cc:308
 hmdccalibrater1.cc:309
 hmdccalibrater1.cc:310
 hmdccalibrater1.cc:311
 hmdccalibrater1.cc:312
 hmdccalibrater1.cc:313
 hmdccalibrater1.cc:314
 hmdccalibrater1.cc:315
 hmdccalibrater1.cc:316
 hmdccalibrater1.cc:317
 hmdccalibrater1.cc:318
 hmdccalibrater1.cc:319
 hmdccalibrater1.cc:320
 hmdccalibrater1.cc:321
 hmdccalibrater1.cc:322
 hmdccalibrater1.cc:323
 hmdccalibrater1.cc:324
 hmdccalibrater1.cc:325
 hmdccalibrater1.cc:326
 hmdccalibrater1.cc:327
 hmdccalibrater1.cc:328
 hmdccalibrater1.cc:329
 hmdccalibrater1.cc:330
 hmdccalibrater1.cc:331
 hmdccalibrater1.cc:332
 hmdccalibrater1.cc:333
 hmdccalibrater1.cc:334
 hmdccalibrater1.cc:335
 hmdccalibrater1.cc:336
 hmdccalibrater1.cc:337
 hmdccalibrater1.cc:338
 hmdccalibrater1.cc:339
 hmdccalibrater1.cc:340
 hmdccalibrater1.cc:341
 hmdccalibrater1.cc:342
 hmdccalibrater1.cc:343
 hmdccalibrater1.cc:344
 hmdccalibrater1.cc:345
 hmdccalibrater1.cc:346
 hmdccalibrater1.cc:347
 hmdccalibrater1.cc:348
 hmdccalibrater1.cc:349
 hmdccalibrater1.cc:350
 hmdccalibrater1.cc:351
 hmdccalibrater1.cc:352
 hmdccalibrater1.cc:353
 hmdccalibrater1.cc:354
 hmdccalibrater1.cc:355
 hmdccalibrater1.cc:356
 hmdccalibrater1.cc:357
 hmdccalibrater1.cc:358
 hmdccalibrater1.cc:359
 hmdccalibrater1.cc:360
 hmdccalibrater1.cc:361
 hmdccalibrater1.cc:362
 hmdccalibrater1.cc:363
 hmdccalibrater1.cc:364
 hmdccalibrater1.cc:365
 hmdccalibrater1.cc:366
 hmdccalibrater1.cc:367
 hmdccalibrater1.cc:368
 hmdccalibrater1.cc:369
 hmdccalibrater1.cc:370
 hmdccalibrater1.cc:371
 hmdccalibrater1.cc:372
 hmdccalibrater1.cc:373
 hmdccalibrater1.cc:374
 hmdccalibrater1.cc:375
 hmdccalibrater1.cc:376
 hmdccalibrater1.cc:377
 hmdccalibrater1.cc:378
 hmdccalibrater1.cc:379
 hmdccalibrater1.cc:380
 hmdccalibrater1.cc:381
 hmdccalibrater1.cc:382
 hmdccalibrater1.cc:383
 hmdccalibrater1.cc:384
 hmdccalibrater1.cc:385
 hmdccalibrater1.cc:386
 hmdccalibrater1.cc:387
 hmdccalibrater1.cc:388
 hmdccalibrater1.cc:389
 hmdccalibrater1.cc:390
 hmdccalibrater1.cc:391
 hmdccalibrater1.cc:392
 hmdccalibrater1.cc:393
 hmdccalibrater1.cc:394
 hmdccalibrater1.cc:395
 hmdccalibrater1.cc:396
 hmdccalibrater1.cc:397
 hmdccalibrater1.cc:398
 hmdccalibrater1.cc:399
 hmdccalibrater1.cc:400
 hmdccalibrater1.cc:401
 hmdccalibrater1.cc:402
 hmdccalibrater1.cc:403
 hmdccalibrater1.cc:404
 hmdccalibrater1.cc:405
 hmdccalibrater1.cc:406
 hmdccalibrater1.cc:407
 hmdccalibrater1.cc:408
 hmdccalibrater1.cc:409
 hmdccalibrater1.cc:410
 hmdccalibrater1.cc:411
 hmdccalibrater1.cc:412
 hmdccalibrater1.cc:413
 hmdccalibrater1.cc:414
 hmdccalibrater1.cc:415
 hmdccalibrater1.cc:416
 hmdccalibrater1.cc:417
 hmdccalibrater1.cc:418
 hmdccalibrater1.cc:419
 hmdccalibrater1.cc:420
 hmdccalibrater1.cc:421
 hmdccalibrater1.cc:422
 hmdccalibrater1.cc:423
 hmdccalibrater1.cc:424
 hmdccalibrater1.cc:425
 hmdccalibrater1.cc:426
 hmdccalibrater1.cc:427
 hmdccalibrater1.cc:428
 hmdccalibrater1.cc:429
 hmdccalibrater1.cc:430
 hmdccalibrater1.cc:431
 hmdccalibrater1.cc:432
 hmdccalibrater1.cc:433
 hmdccalibrater1.cc:434
 hmdccalibrater1.cc:435
 hmdccalibrater1.cc:436
 hmdccalibrater1.cc:437
 hmdccalibrater1.cc:438
 hmdccalibrater1.cc:439
 hmdccalibrater1.cc:440
 hmdccalibrater1.cc:441
 hmdccalibrater1.cc:442
 hmdccalibrater1.cc:443
 hmdccalibrater1.cc:444
 hmdccalibrater1.cc:445
 hmdccalibrater1.cc:446
 hmdccalibrater1.cc:447
 hmdccalibrater1.cc:448
 hmdccalibrater1.cc:449
 hmdccalibrater1.cc:450
 hmdccalibrater1.cc:451
 hmdccalibrater1.cc:452
 hmdccalibrater1.cc:453
 hmdccalibrater1.cc:454
 hmdccalibrater1.cc:455
 hmdccalibrater1.cc:456
 hmdccalibrater1.cc:457
 hmdccalibrater1.cc:458
 hmdccalibrater1.cc:459
 hmdccalibrater1.cc:460
 hmdccalibrater1.cc:461
 hmdccalibrater1.cc:462
 hmdccalibrater1.cc:463
 hmdccalibrater1.cc:464
 hmdccalibrater1.cc:465
 hmdccalibrater1.cc:466
 hmdccalibrater1.cc:467
 hmdccalibrater1.cc:468
 hmdccalibrater1.cc:469
 hmdccalibrater1.cc:470
 hmdccalibrater1.cc:471
 hmdccalibrater1.cc:472
 hmdccalibrater1.cc:473
 hmdccalibrater1.cc:474
 hmdccalibrater1.cc:475
 hmdccalibrater1.cc:476
 hmdccalibrater1.cc:477
 hmdccalibrater1.cc:478
 hmdccalibrater1.cc:479
 hmdccalibrater1.cc:480
 hmdccalibrater1.cc:481
 hmdccalibrater1.cc:482
 hmdccalibrater1.cc:483
 hmdccalibrater1.cc:484
 hmdccalibrater1.cc:485
 hmdccalibrater1.cc:486
 hmdccalibrater1.cc:487
 hmdccalibrater1.cc:488
 hmdccalibrater1.cc:489
 hmdccalibrater1.cc:490
 hmdccalibrater1.cc:491
 hmdccalibrater1.cc:492
 hmdccalibrater1.cc:493
 hmdccalibrater1.cc:494
 hmdccalibrater1.cc:495
 hmdccalibrater1.cc:496
 hmdccalibrater1.cc:497
 hmdccalibrater1.cc:498
 hmdccalibrater1.cc:499
 hmdccalibrater1.cc:500
 hmdccalibrater1.cc:501
 hmdccalibrater1.cc:502
 hmdccalibrater1.cc:503
 hmdccalibrater1.cc:504
 hmdccalibrater1.cc:505
 hmdccalibrater1.cc:506
 hmdccalibrater1.cc:507
 hmdccalibrater1.cc:508
 hmdccalibrater1.cc:509
 hmdccalibrater1.cc:510
 hmdccalibrater1.cc:511
 hmdccalibrater1.cc:512
 hmdccalibrater1.cc:513
 hmdccalibrater1.cc:514
 hmdccalibrater1.cc:515
 hmdccalibrater1.cc:516
 hmdccalibrater1.cc:517
 hmdccalibrater1.cc:518
 hmdccalibrater1.cc:519
 hmdccalibrater1.cc:520
 hmdccalibrater1.cc:521
 hmdccalibrater1.cc:522
 hmdccalibrater1.cc:523
 hmdccalibrater1.cc:524
 hmdccalibrater1.cc:525
 hmdccalibrater1.cc:526
 hmdccalibrater1.cc:527
 hmdccalibrater1.cc:528
 hmdccalibrater1.cc:529
 hmdccalibrater1.cc:530
 hmdccalibrater1.cc:531
 hmdccalibrater1.cc:532
 hmdccalibrater1.cc:533
 hmdccalibrater1.cc:534
 hmdccalibrater1.cc:535
 hmdccalibrater1.cc:536
 hmdccalibrater1.cc:537
 hmdccalibrater1.cc:538
 hmdccalibrater1.cc:539
 hmdccalibrater1.cc:540
 hmdccalibrater1.cc:541
 hmdccalibrater1.cc:542
 hmdccalibrater1.cc:543
 hmdccalibrater1.cc:544
 hmdccalibrater1.cc:545
 hmdccalibrater1.cc:546
 hmdccalibrater1.cc:547
 hmdccalibrater1.cc:548
 hmdccalibrater1.cc:549
 hmdccalibrater1.cc:550
 hmdccalibrater1.cc:551
 hmdccalibrater1.cc:552
 hmdccalibrater1.cc:553
 hmdccalibrater1.cc:554
 hmdccalibrater1.cc:555
 hmdccalibrater1.cc:556
 hmdccalibrater1.cc:557
 hmdccalibrater1.cc:558
 hmdccalibrater1.cc:559
 hmdccalibrater1.cc:560
 hmdccalibrater1.cc:561
 hmdccalibrater1.cc:562
 hmdccalibrater1.cc:563
 hmdccalibrater1.cc:564
 hmdccalibrater1.cc:565
 hmdccalibrater1.cc:566
 hmdccalibrater1.cc:567
 hmdccalibrater1.cc:568
 hmdccalibrater1.cc:569
 hmdccalibrater1.cc:570
 hmdccalibrater1.cc:571
 hmdccalibrater1.cc:572
 hmdccalibrater1.cc:573
 hmdccalibrater1.cc:574
 hmdccalibrater1.cc:575
 hmdccalibrater1.cc:576
 hmdccalibrater1.cc:577
 hmdccalibrater1.cc:578
 hmdccalibrater1.cc:579
 hmdccalibrater1.cc:580
 hmdccalibrater1.cc:581
 hmdccalibrater1.cc:582
 hmdccalibrater1.cc:583
 hmdccalibrater1.cc:584
 hmdccalibrater1.cc:585
 hmdccalibrater1.cc:586
 hmdccalibrater1.cc:587
 hmdccalibrater1.cc:588
 hmdccalibrater1.cc:589
 hmdccalibrater1.cc:590
 hmdccalibrater1.cc:591
 hmdccalibrater1.cc:592
 hmdccalibrater1.cc:593
 hmdccalibrater1.cc:594
 hmdccalibrater1.cc:595
 hmdccalibrater1.cc:596
 hmdccalibrater1.cc:597
 hmdccalibrater1.cc:598
 hmdccalibrater1.cc:599
 hmdccalibrater1.cc:600
 hmdccalibrater1.cc:601
 hmdccalibrater1.cc:602
 hmdccalibrater1.cc:603
 hmdccalibrater1.cc:604
 hmdccalibrater1.cc:605
 hmdccalibrater1.cc:606
 hmdccalibrater1.cc:607
 hmdccalibrater1.cc:608
 hmdccalibrater1.cc:609
 hmdccalibrater1.cc:610
 hmdccalibrater1.cc:611
 hmdccalibrater1.cc:612
 hmdccalibrater1.cc:613
 hmdccalibrater1.cc:614
 hmdccalibrater1.cc:615
 hmdccalibrater1.cc:616
 hmdccalibrater1.cc:617
 hmdccalibrater1.cc:618
 hmdccalibrater1.cc:619
 hmdccalibrater1.cc:620
 hmdccalibrater1.cc:621
 hmdccalibrater1.cc:622
 hmdccalibrater1.cc:623
 hmdccalibrater1.cc:624
 hmdccalibrater1.cc:625
 hmdccalibrater1.cc:626
 hmdccalibrater1.cc:627
 hmdccalibrater1.cc:628
 hmdccalibrater1.cc:629
 hmdccalibrater1.cc:630
 hmdccalibrater1.cc:631
 hmdccalibrater1.cc:632
 hmdccalibrater1.cc:633
 hmdccalibrater1.cc:634
 hmdccalibrater1.cc:635
 hmdccalibrater1.cc:636
 hmdccalibrater1.cc:637
 hmdccalibrater1.cc:638
 hmdccalibrater1.cc:639
 hmdccalibrater1.cc:640
 hmdccalibrater1.cc:641