ROOT logo
//*-- AUTHOR : J. Markert

//_HADES_CLASS_DESCRIPTION 
////////////////////////////////////////////////////////////////////////////
// HMdcCal2ParSim
//
// Container class for the calibration parameters from Cal1 to Cal2 of the MDC
// distance -> time.Contains functions for calculating distance->time for track fitter
// and Digitizer of Mdc
////////////////////////////////////////////////////////////////////////////

#include "hmdccal2parsim.h"
#include "hmdccal2par.h"
#include "hades.h"
#include "hruntimedb.h"
#include "hspectrometer.h"
#include "hmdcdetector.h"
#include "hpario.h"
#include "hdetpario.h"
#include "hmessagemgr.h"
#include "TH2.h"
#include "TStyle.h"
#include "TROOT.h"
#include "TGraphErrors.h"
#include "TCanvas.h"
#include "TF1.h"
#include "TMath.h"

#include <stdlib.h>
#include <iostream> 
#include <iomanip>
using namespace std;

ClassImp(HMdcCal2ParAngleSim)
ClassImp(HMdcCal2ParModSim)
ClassImp(HMdcCal2ParSecSim)
ClassImp(HMdcCal2ParSim)



void HMdcCal2ParAngleSim::fillTime1(HMdcCal2ParAngleSim& r) {
    for(Int_t i=0;i<100;i++)
    {
	drifttime1[i]=r.drifttime1[i];
    }
}
void HMdcCal2ParAngleSim::fillTime2(HMdcCal2ParAngleSim& r) {
    for(Int_t i=0;i<100;i++)
    {
	drifttime2[i]=r.drifttime2[i];
    }
}
void HMdcCal2ParAngleSim::fillTime1Error(HMdcCal2ParAngleSim& r) {
    for(Int_t i=0;i<100;i++)
    {
	drifttime1Err[i]=r.drifttime1Err[i];
    }
}
void HMdcCal2ParAngleSim::fillTime2Error(HMdcCal2ParAngleSim& r) {
    for(Int_t i=0;i<100;i++)
    {
	drifttime2Err[i]=r.drifttime2Err[i];
    }
}


HMdcCal2ParModSim::HMdcCal2ParModSim(Int_t sec, Int_t mod, Int_t angle) {
  // constructor takes the sector, module and angle
    array = new TObjArray(angle);
    for (Int_t i=0; i<angle; ++i)
        array->AddAt(new HMdcCal2ParAngleSim(),i);
}

HMdcCal2ParModSim::~HMdcCal2ParModSim() {
  // destructor
  array->Delete();
  delete array;
}

HMdcCal2ParSecSim::HMdcCal2ParSecSim(Int_t sec, Int_t mod) {
  // constructor takes the sector, module number
  array = new TObjArray(mod);
  for (Int_t i=0; i<mod; i++)
        array->AddAt(new HMdcCal2ParModSim(sec,i),i);
}

HMdcCal2ParSecSim::~HMdcCal2ParSecSim() {
  // destructor
  array->Delete();
  delete array;
}

HMdcCal2ParSim::HMdcCal2ParSim(const Char_t* name,const Char_t* title,
                         const Char_t* context,Int_t n)
               : HParSet(name,title,context) {
  // constructor
  comment="no comment";
  strcpy(detName,"Mdc");
  if (gHades) {
      fMdc = (HMdcDetector*)(((HSpectrometer*)(gHades->getSetup()))->getDetector("Mdc"));
  } else {
      fMdc = 0;
  }
  array = new TObjArray(n);
  for (Int_t i=0; i<n; i++) array->AddAt(new HMdcCal2ParSecSim(i),i);
  linecounter=0;
  linecounterwrite=0;
  type=0;
  slopeOutside=100.;  // 100 ns/mm

  useConstErr=kFALSE;
  useConstVD =kFALSE;
  for (Int_t i=0; i<4; i++)
  {
      scaleError[i]=1.;
      constError[i]=140.;
      constVD[i]   =40.;
  }
}

HMdcCal2ParSim::~HMdcCal2ParSim() {
  // destructor
  array->Delete();
  delete array;
}

Bool_t HMdcCal2ParSim::init(HParIo* inp,Int_t* set) {
  // intitializes the container from an input
    linecounter=0;
    linecounterwrite=0;
    type=0;

    HDetParIo* input=inp->getDetParIo("HMdcParIo");
    if(!input) return kFALSE;
    Bool_t init=input->init(this,set);
    if(!init)  return kFALSE;
    if(!hasChanged()) return kTRUE;

    if(scaleError[0]!=1||scaleError[1]!=1||scaleError[2]!=1||scaleError[3]!=1)
    {
	cout<<"HMdcCal2ParSim: scaling errors of time1 by : "<<endl;
	cout<<"\t module 0 : "<<scaleError[0]<<endl;
	cout<<"\t module 1 : "<<scaleError[1]<<endl;
	cout<<"\t module 2 : "<<scaleError[2]<<endl;
	cout<<"\t module 3 : "<<scaleError[3]<<endl;

    }
    if(useConstErr)
    {
	cout<<"HMdcCal2ParSim::init(): const errors of time1 : "<<endl;
	cout<<"\t module 0 : "<<constError[0]<<endl;
	cout<<"\t module 1 : "<<constError[1]<<endl;
	cout<<"\t module 2 : "<<constError[2]<<endl;
	cout<<"\t module 3 : "<<constError[3]<<endl;
    }
    if(useConstVD)
    {
	cout<<"HMdcCal2ParSim::init(): const Drift velocity : "<<endl;
	cout<<"\t module 0 : "<<constVD[0]<<endl;
	cout<<"\t module 1 : "<<constVD[1]<<endl;
	cout<<"\t module 2 : "<<constVD[2]<<endl;
	cout<<"\t module 3 : "<<constVD[3]<<endl;
    }
    for(Int_t s=0;s<getSize();s++) {
	HMdcCal2ParSecSim& sec=(*this)[s];
	for(Int_t m=0;m<sec.getSize();m++) {
	    HMdcCal2ParModSim& mod=sec[m];
	    for(Int_t l=0;l<18;l++) {
		HMdcCal2ParAngleSim& rAngle=mod[l];
		for(Int_t i=0;i<100;i++)
		{
                    if(useConstVD)  rAngle.drifttime1   [i]=(1./ constVD[m])*i*100.;
                    if(useConstErr) rAngle.drifttime1Err[i]=constError[m];
		    else
		    {
                        if(scaleError[m]==1) continue;
			if(rAngle.drifttime1Err[i]*scaleError[m]<30.) rAngle.drifttime1Err[i]=rAngle.drifttime1Err[i]*scaleError[m];
                        else                                          rAngle.drifttime1Err[i]=30.;
		    }
		}
	    }
	}
    }

    return kTRUE;
}
Double_t HMdcCal2ParSim::calcTime(Int_t s,Int_t m,Double_t a,Double_t dist) {
    // This function calculates the drift time for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    if(!finite(a)||!finite(dist))
    {
	Error("calcTime()","received non finite value alpha %f dist %f!",a,dist);
        return -1;
    }
    Double_t angle=90.-a;
    Double_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined
  
    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Double_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Double_t finalTime;
    if(dminI>98)
    {   // distance outside matrix
	Double_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime1[99];
	Double_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime1[99];

	Double_t t=angleStepD - angleStepI;

        finalTime=y1-t*(y1-y2);
	return finalTime;
    }

    //#################################### calc drift time ######################   
    Double_t y1=rAngle.drifttime1 [dminI];
    Double_t y2=rAngle2.drifttime1[dminI];
    Double_t y3=rAngle2.drifttime1[dminI+1];
    Double_t y4=rAngle.drifttime1 [dminI+1];

    Double_t t=angleStepD - angleStepI;
    Double_t u=dminF - dminI;

    finalTime=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
    return finalTime;
}
Double_t HMdcCal2ParSim::calcTimeErr(Int_t s,Int_t m,Double_t a,Double_t dist) {
    // This function calculates the Error of drift time1 for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.
    if(!finite(a)||!finite(dist))
    {
	Error("calcTimeErr()","received non finite value alpha %f dist %f!",a,dist);
        return -1;
    }

    Double_t angle=90.-a;
    Double_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined
  
    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Double_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Double_t finalErr;
    if(dminI>98)
    {   // distance outside matrix
	Double_t y1= rAngle.drifttime1Err[99];
	Double_t y2= rAngle2.drifttime1Err[99];

	Double_t t=angleStepD - angleStepI;

        finalErr=y1-t*(y1-y2);
	return finalErr;
    }

    //#################################### calc drift time Error ######################
    Double_t y1=rAngle.drifttime1Err [dminI];
    Double_t y2=rAngle2.drifttime1Err[dminI];
    Double_t y3=rAngle2.drifttime1Err[dminI+1];
    Double_t y4=rAngle.drifttime1Err [dminI+1];

    Double_t t=angleStepD - angleStepI;
    Double_t u=dminF - dminI;

    finalErr=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
    return finalErr;
}
void HMdcCal2ParSim::calcTime(Int_t s,Int_t m,Double_t a,Double_t dist
			      ,Double_t*time1,Double_t*time1Err)
{
    // This function calculates the drift time for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.
    // Time1 and Error of Time1 (no random smearing) are returned to Float pointers

    if(!finite(a)||!finite(dist))
    {
	Error("calcTime()","received non finite value alpha %f dist %f!",a,dist);
	*time1   =-1;
        *time1Err=-1;
	return ;
    }
    Double_t angle=90.-a;
    Double_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined
  
    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Double_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    if(dminI>98)
    {   // distance outside matrix
	Double_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime1[99];
	Double_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime1[99];

	Double_t t=angleStepD - angleStepI;

        *time1=y1-t*(y1-y2);

	y1=rAngle.drifttime1Err[99];
	y2=rAngle2.drifttime1Err[99];

        *time1Err=y1-t*(y1-y2);
    }
    else
    {
	//#################################### calc drift time ######################
	Double_t y1=rAngle.drifttime1 [dminI];
	Double_t y2=rAngle2.drifttime1[dminI];
	Double_t y3=rAngle2.drifttime1[dminI+1];
	Double_t y4=rAngle.drifttime1 [dminI+1];

	Double_t t=angleStepD - angleStepI;
	Double_t u=dminF - dminI;

	*time1=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);

	//################################ calc errors ######################################
	y1=rAngle.drifttime1Err [dminI];
	y2=rAngle2.drifttime1Err[dminI];
	y3=rAngle2.drifttime1Err[dminI+1];
	y4=rAngle.drifttime1Err [dminI+1];

	*time1Err=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
    }
}
Float_t HMdcCal2ParSim::calcTime(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the drift time for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    if(!finite(a)||!finite(dist))
    {
	Error("calcTime()","received non finite value alpha %f dist %f!",a,dist);
	return -1;
    }
    if((Int_t)((90-a)/5.)<0)
    {   // dummy fix for over flow
	a=angleDeg;
	dist=distance;
    }

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined
  
    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Float_t finalTime;
    if(dminI>98)
    {   // distance outside matrix
	Float_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime1[99];
	Float_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime1[99];

	Float_t t=angleStepD - angleStepI;

        finalTime=y1-t*(y1-y2);
	return finalTime;
    }

    //#################################### calc drift time ######################   
    Float_t y1=rAngle.drifttime1 [dminI];
    Float_t y2=rAngle2.drifttime1[dminI];
    Float_t y3=rAngle2.drifttime1[dminI+1];
    Float_t y4=rAngle.drifttime1 [dminI+1];

    Float_t t=angleStepD - angleStepI;
    Float_t u=dminF - dminI;

    finalTime=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);

    distance=dist; // just to cover the over flow
    angleDeg=a;

    return finalTime;
}
Float_t HMdcCal2ParSim::calcTimeErr(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the Error of drift time1 for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.
    if(!finite(a)||!finite(dist))
    {
	Error("calcTimeErr()","received non finite value alpha %f dist %f!",a,dist);
	return -1;
    }

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined

    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Float_t finalErr;
    if(dminI>98)
    {   // distance outside matrix

        Float_t t=angleStepD - angleStepI;

	Float_t y1=rAngle.drifttime1Err[99];
	Float_t y2=rAngle2.drifttime1Err[99];

	finalErr=y1-t*(y1-y2);
	return finalErr;
    }
    else
    {
	//################################ calc errors ######################################

        Float_t t=angleStepD - angleStepI;
	Float_t u=dminF - dminI;

        Float_t y1=rAngle.drifttime1Err [dminI];
	Float_t y2=rAngle2.drifttime1Err[dminI];
	Float_t y3=rAngle2.drifttime1Err[dminI+1];
	Float_t y4=rAngle.drifttime1Err [dminI+1];

	finalErr=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
        return finalErr;
    }
}

Float_t HMdcCal2ParSim::calcTime2(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the drift time2 for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined

    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Float_t finalTime;

    if(dminI>98)
    {   // distance outside matrix
	Float_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime2[99];
	Float_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime2[99];

	Float_t t=angleStepD - angleStepI;

        finalTime=y1-t*(y1-y2);
        return finalTime;

    }
    else
    {
	//################################ calc time2 ######################################

	Float_t y1=rAngle.drifttime2 [dminI];
	Float_t y2=rAngle2.drifttime2[dminI];
	Float_t y3=rAngle2.drifttime2[dminI+1];
	Float_t y4=rAngle.drifttime2 [dminI+1];

	Float_t t=angleStepD - angleStepI;
	Float_t u=dminF - dminI;

	finalTime=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
        return finalTime;
    }
}
Float_t HMdcCal2ParSim::calcTime2Err(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the Error drift time2 for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined

    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    Float_t finalErr;
    if(dminI>98)
    {   // distance outside matrix
	Float_t t=angleStepD - angleStepI;

	Float_t y1=rAngle.drifttime2Err[99];
	Float_t y2=rAngle2.drifttime2Err[99];

	finalErr=y1-t*(y1-y2);
        return finalErr;
    }
    else
    {
	//################################ calc errors ######################################
 	Float_t t=angleStepD - angleStepI;
	Float_t u=dminF - dminI;

        Float_t y1=rAngle.drifttime2Err [dminI];
	Float_t y2=rAngle2.drifttime2Err[dminI];
	Float_t y3=rAngle2.drifttime2Err[dminI+1];
	Float_t y4=rAngle.drifttime2Err [dminI+1];

	finalErr=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
        return finalErr;
    }
}
Float_t HMdcCal2ParSim::calcDriftVelocity(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the drift velocity for a given distance
    // to sense wire and impact angle. Vd [mu/ns] = deltaT1/deltaDist

    Float_t finalVd=0;
    Float_t t1_1=0;
    Float_t t1_2=0;
    Float_t mystep=0.1; // mm->100mu

    if(dist>=0)
    {
	t1_1=calcTime(s,m,a,dist);
        t1_2=calcTime(s,m,a,dist+mystep);
    }
    if(t1_1-t1_2!=0)finalVd=1000*fabs(mystep/(t1_1-t1_2)); // mu/ns

    return finalVd;
}
Float_t HMdcCal2ParSim::calcResolution(Int_t s,Int_t m,Float_t a,Float_t dist) {
    // This function calculates the reslution in nm for a given distance
    // to sense wire and impact angle. Res[nm]=timeErr/Vd.

    Float_t finalRes=0;

    Float_t Vd=calcDriftVelocity(s,m,a,dist);
    if(Vd>0)
    {
      finalRes=fabs(Vd*calcTimeErr(s,m,a,dist)); // (mu/ns)*ns=>mu
    }

    return finalRes;
}
void HMdcCal2ParSim::calcTimeDigitizer(Int_t s,Int_t m,Float_t a,
				       Float_t dist,Float_t*time1,Float_t*time1Err) {
    // This function calculates the drift time for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined

    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    if(dminI>98)
    {   // distance outside matrix
	Float_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime1[99];
	Float_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime1[99];

	Float_t t=angleStepD - angleStepI;

        *time1=y1-t*(y1-y2);

	y1=rAngle.drifttime1Err[99];
	y2=rAngle2.drifttime1Err[99];

	Float_t TimeResolution=y1-t*(y1-y2);
	Float_t gauss=gRandom->Gaus(0,1); // random value between -1 and 1

	*time1Err=TimeResolution*gauss;

    }
    else
    {
	//################################ calc time1 ######################################

	Float_t y1=rAngle.drifttime1 [dminI];
	Float_t y2=rAngle2.drifttime1[dminI];
	Float_t y3=rAngle2.drifttime1[dminI+1];
	Float_t y4=rAngle.drifttime1 [dminI+1];

	Float_t t=angleStepD - angleStepI;
	Float_t u=dminF - dminI;

	Float_t Time1=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);

	//################################ calc errors ######################################
	y1=rAngle.drifttime1Err [dminI];
	y2=rAngle2.drifttime1Err[dminI];
	y3=rAngle2.drifttime1Err[dminI+1];
	y4=rAngle.drifttime1Err [dminI+1];

	Float_t TimeResolution=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
	Float_t gauss=gRandom->Gaus(0,1); // random value between -1 and 1

	*time1=Time1;
	*time1Err=TimeResolution*gauss;
    }
}
void HMdcCal2ParSim::calcTime2Digitizer(Int_t s,Int_t m,Float_t a,
					Float_t dist,Float_t*time2,Float_t*time2Err) {
    // This function calculates the drift time for a given distance
    // to sense wire.A Interpolation between the two closest angle steps
    // is performed and the drift time value returned.
    // Input is the angle of the track (alphaTrack:90 degree for perpendicular impact),which
    // has to be recalculated to the angle of minimum drift distance (alphaDrDist:0 degree for
    // perpendicular impact).
    //   y ^
    //     |  |------------*----|              cathod  plane
    //     |  | cell        *   |
    //     |  |            / *  |
    //     |  |           /90 * |
    //     |  | driftDist/     *|
    //     |  |         / |     *
    //   --|--|--------*^-|-----|*--------->   sense/potential plane
    //     |  |           |     | *        x
    //     |  |      alphaDrDist|  *
    //        |                 |/  *          alphaDriftDist=90-alphaTrack
    //        |      alphaTrack /    *
    //        |-----------------|     * track  cathod plane
    //
    // angles must be between 0 and 90 degree, all other angles have to be shifted
    // before calling the function.

    Float_t angle=90.-a;
    Float_t angleStepD=angle/5;
    Int_t angleStepI=Int_t(angleStepD);
    if(angleStepI==18)angleStepI=17;      // if angle==90, angleStepI=18 ->not defined

    HMdcCal2ParAngleSim& rAngle =(*this)[s][m][angleStepI];// pointer to the first set
    HMdcCal2ParAngleSim& rAngle2=(angleStepI<17) ? (*this)[s][m][angleStepI+1] : rAngle;

    Float_t dminF=dist/0.1;
    Int_t dminI=Int_t(dminF); 

    if(dminI>98)
    {   // distance outside matrix
	Float_t y1=(dist-9.9)*slopeOutside + rAngle.drifttime2[99];
	Float_t y2=(dist-9.9)*slopeOutside + rAngle2.drifttime2[99];

	Float_t t=angleStepD - angleStepI;

        *time2=y1-t*(y1-y2);

	y1=rAngle.drifttime2Err[99];
	y2=rAngle2.drifttime2Err[99];

	Float_t TimeResolution=y1-t*(y1-y2);
	Float_t gauss=gRandom->Gaus(0,1); // random value between -1 and 1

	*time2Err=TimeResolution*gauss;

    }
    else
    {

	//################################ calc time2 ######################################

	Float_t y1=rAngle.drifttime2 [dminI];
	Float_t y2=rAngle2.drifttime2[dminI];
	Float_t y3=rAngle2.drifttime2[dminI+1];
	Float_t y4=rAngle.drifttime2 [dminI+1];

	Float_t t=angleStepD - angleStepI;
	Float_t u=dminF - dminI;

	Float_t Time2=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);

	//################################ calc errors ######################################
	y1=rAngle.drifttime2Err [dminI];
	y2=rAngle2.drifttime2Err[dminI];
	y3=rAngle2.drifttime2Err[dminI+1];
	y4=rAngle.drifttime2Err [dminI+1];

	Float_t Time2Resolution=y1-t*(y1-y2)-u*(y1-y4)+t*u*(y1-y2+y3-y4);
	Float_t gauss=gRandom->Gaus(0,1); // random value between -1 and 1

	*time2=Time2;
	*time2Err=Time2Resolution*gauss;
    }
}
void HMdcCal2ParSim::transformToDistance(Int_t s,Int_t m,Int_t a,Float_t binsizetime,HMdcCal2Par* cal2par)
{
 // fills arrays of MdcCal2Par (time) from arrays of MdcCal2ParSim (distance)
    Float_t time1_1=0;
    Float_t time1_2=0;
    Float_t time1_1Err=0;
    Float_t time1_2Err=0;
    Int_t timebin =0;
    Float_t dsearch   =0; // mm
    Float_t dsearchErr=0; // ns
    Float_t vdrift=0;     // 0.1 *mm/ns
    Float_t unit=0.1;
    Float_t dsearchold=0;    // mm
    Float_t dsearchErrold=0; // mm

    for(Int_t b=1;b<100;b++)
    {   // time bin (4ns)
	time1_1=0;
	time1_2=0;
	time1_1Err=0;
	time1_2Err=0;
	timebin =0;
	dsearch   =0;
	dsearchErr=0;
	vdrift=0;
   
	while(time1_1<b*binsizetime && timebin<99)
	{   // find bin which corresponds to given time
	    timebin++; // bin number in htime (0.1mm)
	    time1_1 = (*this)[s][m][a].drifttime1[timebin];
	}
	// doing interpolation between two closest points
	time1_2    = (*this)[s][m][a].drifttime1   [timebin];
	time1_2Err = (*this)[s][m][a].drifttime1Err[timebin];
        time1_1    = (*this)[s][m][a].drifttime1   [timebin-1];
	time1_1Err = (*this)[s][m][a].drifttime1Err[timebin-1];

	if( (time1_2-time1_1)!=0)
	{
	    dsearch    = ((b*binsizetime - time1_1)*(unit/(time1_2-time1_1))) + (timebin-1)*unit;

	    if(dsearch==dsearchold)
	    {  // just check if value does not change (should never be the case)
		gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
				       ,"dsearch==dsearchold %i %i %i vd (um/ns) %f ds %f es (ns) %f e1 %f e2 %f res (um) %f"
				       ,m,a,b,vdrift*1000,dsearch,dsearchErr,time1_1Err,time1_2Err,dsearchErr*vdrift*1000);
	    }

	    if( (time1_2Err-time1_1Err)!=0 || useConstErr)
	    {
		if(!useConstErr){
		    dsearchErr = time1_1Err + ( (time1_2Err-time1_1Err)/unit)*(dsearch-(timebin-1)*unit);
		    dsearchErrold=dsearchErr;
		} else {
		    dsearchErr = dsearchold = time1_1Err;
		}

	    }
	    else
	    {   // take the error from previous point
		if(dsearch==dsearchold)
		{
		    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
					   ,"take the error from previous point %i %i %i vd (um/ns) %f ds %f es(ns) %f e1 %f e2 %f res(um) %f"
					   ,m,a,b,vdrift*1000,dsearch,dsearchErr,time1_1Err,time1_2Err,dsearchErr*vdrift*1000);
		}
		dsearchErr=dsearchErrold;
	    }
	    vdrift= (unit/ (time1_2-time1_1)); //

            (*cal2par)[s][m][a].distance   [b]=dsearch;
            (*cal2par)[s][m][a].distanceErr[b]=dsearchErr*vdrift;

	    if(dsearch==0)
	    {
		gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
				       ,"dsearch==0 %i %i %i e1 %f e2 %f t1 %f t2 %f"
				       ,m,a,b,time1_1Err,time1_2Err,time1_1,time1_2);
	    }
	}
	else
	{
	    if(b>2)
	    {
		gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName()
				       ,"time1_2-time1_1==0 %i %i %i e1 %f e2 %f t1 %f t2 %f"
				       ,m,a,b,time1_1Err,time1_2Err,time1_1,time1_2);
	    }
	}
    }
    // doing linear interpolation between first real value and 0
    // to avoid natsty peak at 0
    Int_t first=0;
    while((*cal2par)[s][m][a].distance[first]==0)
    {
	first++;
    }
    if(first>0)
    {
        Float_t slope= (*cal2par)[s][m][a].distance[first]/first;
	for(Int_t bin=0;bin<first;bin++)
	{
	    (*cal2par)[s][m][a].distance   [bin]=bin*slope;
            (*cal2par)[s][m][a].distanceErr[bin]=(*cal2par)[s][m][a].distanceErr[first];
	}
    }
}
void HMdcCal2ParSim::plot(Int_t s,Int_t m)
{
    // plots data into TGraphErrors for time1 and time2 including errors

    cout<<"HMdcCal2ParSim: plotting sector "<<s<<" module "<<m<<endl;

    gStyle->SetOptStat(0);
    gStyle->SetOptTitle(0);
    gStyle->SetPalette(1);

    Char_t nameCanvas[300];
    sprintf(nameCanvas,"%s %i %s %i","distance -> time sector ",s," module ",m);

    TH2F* dummy=new TH2F("dummy","dummy",2,0,10.1,2,0,700);
    dummy->SetXTitle("distance from wire [mm]");
    dummy->SetYTitle("drift time [ns]");

    TCanvas* result=new TCanvas(nameCanvas,nameCanvas,1000,800);
    result->Divide(6,3);
    result->Draw();
    Float_t x[100];
    Float_t y[100];
    Float_t ex[100];
    Float_t ey[100];
    Float_t x2[100];
    Float_t y2[100];
    Float_t ex2[100];
    Float_t ey2[100];

    for(Int_t a=0;a<18;a++)
    {
	for(Int_t i=0;i<100;i++)
	{
		x[i] =i*0.1;
		y[i] =(*this)[s][m][a].drifttime1[i];
		ex[i]=0;
		ey[i]=(*this)[s][m][a].drifttime1Err[i];
		x2[i] =i*0.1;
		y2[i] =(*this)[s][m][a].drifttime2[i];
		ex2[i]=0;
		ey2[i]=(*this)[s][m][a].drifttime2Err[i];
	}
	result->cd(a+1);
        dummy->DrawCopy();
	TGraphErrors* g=new TGraphErrors(100,x,y,ex,ey);
	g->SetLineColor(2);
        g->Draw();
        TGraphErrors* g2=new TGraphErrors(100,x2,y2,ex2,ey2);
	g2->SetLineColor(4);
        g2->Draw();
    }
    result->Update();
    delete dummy;
}
void HMdcCal2ParSim::plot2D(Int_t s,Int_t m,Int_t type)
{
    // Plots data into 2d-Hists
    // type = 0 ->time1
    // type = 1 ->Error time1
    // type = 2 ->time2
    // type = 3 ->Error time2

    cout<<"HMdcCal2ParSim: plotting 2D sector "<<s<<" module "<<m<<endl;

    gStyle->SetOptStat(0);
    gStyle->SetOptTitle(0);
    gStyle->SetPalette(1);

    Char_t nameCanvas[300];
    if(type==0)sprintf(nameCanvas,"%s %i %s %i","time1 sector ",s," module ",m);
    if(type==1)sprintf(nameCanvas,"%s %i %s %i","Error time1 sector ",s," module ",m);
    if(type==2)sprintf(nameCanvas,"%s %i %s %i","time2 sector ",s," module ",m);
    if(type==3)sprintf(nameCanvas,"%s %i %s %i","Error time2 sector ",s," module ",m);

    TH2F* dummy=new TH2F("dummy","dummy",18,0,90,100,0,10);
   
    dummy->SetXTitle("angle");
    dummy->SetYTitle("distance from wire [mm]");

    if(type==0)dummy->SetZTitle("time1 [ns]");
    if(type==1)dummy->SetZTitle("Error time1 [ns]");
    if(type==2)dummy->SetZTitle("time2 [ns]");
    if(type==3)dummy->SetZTitle("Error time2 [ns]");

    TCanvas* result=new TCanvas(nameCanvas,nameCanvas,1000,800);

    for(Int_t a=0;a<18;a++)
    {
	for(Int_t i=0;i<100;i++)
	{
	    if(type==0)dummy->SetBinContent(a+1,i,(*this)[s][m][a].drifttime1[i]);
            if(type==1)dummy->SetBinContent(a+1,i,(*this)[s][m][a].drifttime1Err[i]);
            if(type==2)dummy->SetBinContent(a+1,i,(*this)[s][m][a].drifttime2[i]);
            if(type==3)dummy->SetBinContent(a+1,i,(*this)[s][m][a].drifttime2Err[i]);
	}
    }
    result->cd();
    dummy->DrawCopy("lego2");

    result->Update();
    delete dummy;
}
Int_t HMdcCal2ParSim::write(HParIo* output) {
  // writes the container to an output
  HDetParIo* out=output->getDetParIo("HMdcParIo");
  if (out) return out->write(this);
  return -1;
}
void HMdcCal2ParSim::readline(const Char_t* buf, Int_t* set) {
  // decodes one line read from ascii file I/O and calls HMdcCal2ParAngleSim::fillTime1(...)
  Int_t   sec,mod,angle,type;
  Float_t par1,par2,par3,par4,par5,par6,par7,par8,par9,par10;

  if(linecounter%10==0) linecounter=0;

  sscanf(buf,"%i%i%i%i%*s",&sec, &mod, &angle, &type);
  sscanf(&buf[9],"%f%f%f%f%f%f%f%f%f%f",
         &par1, &par2,
	 &par3, &par4, &par5,
	 &par6, &par7, &par8,
	 &par9, &par10 );

  Int_t n=sec*4+mod;

  if (!set[n]) return;
  HMdcCal2ParAngleSim& rAngle=(*this)[sec][mod][angle];
  switch (type){
  case  0: rAngle.fillTime1(linecounter,par1,par2,par3,par4,par5,par6,par7,par8,par9,par10);
  break;
  case  1:rAngle.fillTime1Error(linecounter,par1,par2,par3,par4,par5,par6,par7,par8,par9,par10);
  break;
  case  2:rAngle.fillTime2(linecounter,par1,par2,par3,par4,par5,par6,par7,par8,par9,par10);
  break;
  case  3:rAngle.fillTime2Error(linecounter,par1,par2,par3,par4,par5,par6,par7,par8,par9,par10);
  break;
  default : Error("HMdcCal2Parsim::readline()","argument \"type\" out of range");
  break;
  }
  linecounter++;

  set[n]=999;
}

void HMdcCal2ParSim::putAsciiHeader(TString& header) {
  // puts the ascii header to the string used in HMdcParAsciiFileIo
  header=
	"# Cal2 Calibration parameters of the MDC\n"
	"# distance->time\n"
	"# Format: type: 0=time1, 1=time2, 2=variation of time1, 3=variation of time2\n"
	"# sector  module  angle type par0 par1 par2 par3 par4 par5 pa6 par7 par8 par9 par10\n";
}

Bool_t HMdcCal2ParSim::writeline(Char_t *buf, Int_t sec, Int_t mod, Int_t angle) {
  // writes one line to the buffer used by ascii file I/O
 Bool_t r = kTRUE;

 if (fMdc) {
     if (fMdc->getModule(sec,mod) != 0) {
	 if  (sec>-1 && sec<getSize()) {
	     HMdcCal2ParSecSim &sector = (*this)[sec];
	     if (mod>-1 && mod<sector.getSize()) {

		 HMdcCal2ParAngleSim& rAngle=(*this)[sec][mod][angle];
		 Char_t dummy[20];

		 if(linecounterwrite%10==0&&linecounterwrite>1)
		 {
		     linecounterwrite=0;
		     type++;
		 }
                 if(type>3)
		 {
		    type=0;
		 }
		 sprintf(dummy,"%1i %1i %2i %1i",sec, mod, angle, type);
		 switch (type){
		 case 0:
		     sprintf(buf,"%s %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
			     dummy,
			     rAngle.getDriftTime1(linecounterwrite,0),rAngle.getDriftTime1(linecounterwrite,1),
			     rAngle.getDriftTime1(linecounterwrite,2),rAngle.getDriftTime1(linecounterwrite,3),
			     rAngle.getDriftTime1(linecounterwrite,4),rAngle.getDriftTime1(linecounterwrite,5),
			     rAngle.getDriftTime1(linecounterwrite,6),rAngle.getDriftTime1(linecounterwrite,7),
			     rAngle.getDriftTime1(linecounterwrite,8),rAngle.getDriftTime1(linecounterwrite,9) );
		     break;
		 case 1:
		     sprintf(buf,"%s %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
			     dummy,
			     rAngle.getDriftTime1Error(linecounterwrite,0),rAngle.getDriftTime1Error(linecounterwrite,1),
			     rAngle.getDriftTime1Error(linecounterwrite,2),rAngle.getDriftTime1Error(linecounterwrite,3),
			     rAngle.getDriftTime1Error(linecounterwrite,4),rAngle.getDriftTime1Error(linecounterwrite,5),
			     rAngle.getDriftTime1Error(linecounterwrite,6),rAngle.getDriftTime1Error(linecounterwrite,7),
			     rAngle.getDriftTime1Error(linecounterwrite,8),rAngle.getDriftTime1Error(linecounterwrite,9) );
		     break;
		 case 2:
		     sprintf(buf,"%s %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
			     dummy,
			     rAngle.getDriftTime2(linecounterwrite,0),rAngle.getDriftTime2(linecounterwrite,1),
			     rAngle.getDriftTime2(linecounterwrite,2),rAngle.getDriftTime2(linecounterwrite,3),
			     rAngle.getDriftTime2(linecounterwrite,4),rAngle.getDriftTime2(linecounterwrite,5),
			     rAngle.getDriftTime2(linecounterwrite,6),rAngle.getDriftTime2(linecounterwrite,7),
			     rAngle.getDriftTime2(linecounterwrite,8),rAngle.getDriftTime2(linecounterwrite,9) );
		     break;
		 case 3:
		     sprintf(buf,"%s %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
			     dummy,
			     rAngle.getDriftTime2Error(linecounterwrite,0),rAngle.getDriftTime2Error(linecounterwrite,1),
			     rAngle.getDriftTime2Error(linecounterwrite,2),rAngle.getDriftTime2Error(linecounterwrite,3),
			     rAngle.getDriftTime2Error(linecounterwrite,4),rAngle.getDriftTime2Error(linecounterwrite,5),
			     rAngle.getDriftTime2Error(linecounterwrite,6),rAngle.getDriftTime2Error(linecounterwrite,7),
			     rAngle.getDriftTime2Error(linecounterwrite,8),rAngle.getDriftTime2Error(linecounterwrite,9) );
                 break;
		 default:Error("HMdcCal2ParSim::writeline()","argument \"type\" out of range ");
                 break;
		 }

		 linecounterwrite++;
	     } else r = kFALSE;
	 }  else r = kFALSE;
     } else { strcpy(buf,""); }
 }

 return r;
}

void HMdcCal2ParSim::clear() {
  // clears the container
  for(Int_t s=0;s<getSize();s++) {
    HMdcCal2ParSecSim& sec=(*this)[s];
    for(Int_t m=0;m<sec.getSize();m++) {
      HMdcCal2ParModSim& mod=sec[m];
      for(Int_t l=0;l<18;l++) {
          HMdcCal2ParAngleSim& angle=mod[l];
          angle.clear();
      }
    }
  }
  status=kFALSE;
  resetInputVersions();
}
void HMdcCal2ParSim::printParam() {
  // prints the container
    for(Int_t s=0;s<getSize();s++) {
	HMdcCal2ParSecSim& sec=(*this)[s];
	for(Int_t m=0;m<sec.getSize();m++) {
	    HMdcCal2ParModSim& mod=sec[m];
	    for(Int_t l=0;l<18;l++) {
		HMdcCal2ParAngleSim& rAngle=mod[l];
		for(Int_t mytype=0;mytype<4;mytype++){
		    for(Int_t myline=0;myline<10;myline++){

		        gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),"%1i %1i %2i %1i",s, m, l, mytype);
			switch (mytype){
			case 0:
			    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
						   "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
						   rAngle.getDriftTime1(myline,0),rAngle.getDriftTime1(myline,1),
						   rAngle.getDriftTime1(myline,2),rAngle.getDriftTime1(myline,3),
						   rAngle.getDriftTime1(myline,4),rAngle.getDriftTime1(myline,5),
						   rAngle.getDriftTime1(myline,6),rAngle.getDriftTime1(myline,7),
						   rAngle.getDriftTime1(myline,8),rAngle.getDriftTime1(myline,9) );
			    break;
			case 1:
			    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
						   "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
						   rAngle.getDriftTime1Error(myline,0),rAngle.getDriftTime1Error(myline,1),
						   rAngle.getDriftTime1Error(myline,2),rAngle.getDriftTime1Error(myline,3),
						   rAngle.getDriftTime1Error(myline,4),rAngle.getDriftTime1Error(myline,5),
						   rAngle.getDriftTime1Error(myline,6),rAngle.getDriftTime1Error(myline,7),
						   rAngle.getDriftTime1Error(myline,8),rAngle.getDriftTime1Error(myline,9) );
			    break;
			case 2:
			    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
						   "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
						   rAngle.getDriftTime2(myline,0),rAngle.getDriftTime2(myline,1),
						   rAngle.getDriftTime2(myline,2),rAngle.getDriftTime2(myline,3),
						   rAngle.getDriftTime2(myline,4),rAngle.getDriftTime2(myline,5),
						   rAngle.getDriftTime2(myline,6),rAngle.getDriftTime2(myline,7),
						   rAngle.getDriftTime2(myline,8),rAngle.getDriftTime2(myline,9) );
			    break;
			case 3:
			    gHades->getMsg()->info(10,HMessageMgr::DET_MDC,GetName(),
						   "%7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f %7.2f\n",
						   rAngle.getDriftTime2Error(myline,0),rAngle.getDriftTime2Error(myline,1),
						   rAngle.getDriftTime2Error(myline,2),rAngle.getDriftTime2Error(myline,3),
						   rAngle.getDriftTime2Error(myline,4),rAngle.getDriftTime2Error(myline,5),
						   rAngle.getDriftTime2Error(myline,6),rAngle.getDriftTime2Error(myline,7),
						   rAngle.getDriftTime2Error(myline,8),rAngle.getDriftTime2Error(myline,9) );
			    break;
			default:Error("HMdcCal2ParSim::printParam()","argument \"type\" out of range ");
			break;
			}
		    }
		}
	    }
	}
    }
}
void HMdcCal2ParSim::Streamer(TBuffer &R__b)
{
   // Stream an object of class HMdcCal2ParSim.

   UInt_t R__s, R__c;
   if (R__b.IsReading())
   {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      if(R__v==2)
      {
	  HParSet::Streamer(R__b);
	  R__b >> array;
	  R__b >> fMdc;
	  comment.Streamer(R__b);
	  R__b >> sector;
	  R__b >> module;
	  R__b >> angleDeg;
	  R__b >> time;
	  R__b >> time2;
	  R__b >> finaltime;
	  R__b >> angleStep;
	  R__b >> distance;
	  R__b >> linecounter;
	  R__b >> linecounterwrite;
	  R__b >> slopeOutside;
	  R__b >> type;
	  R__b >> dmin;
	  R__b >> dmax;
	  R__b.CheckByteCount(R__s, R__c, HMdcCal2ParSim::IsA());
      }
      else if(R__v==1)
      {
	  Warning("HMdcCal2ParSim:Streamer()","Reading old version 1!");
	  HParSet::Streamer(R__b);
	  R__b >> array;
	  R__b >> fMdc;
	  comment.Streamer(R__b);
	  R__b >> sector;
	  R__b >> module;
	  R__b >> angleDeg;
	  R__b >> time;
	  R__b >> time2;
	  R__b >> finaltime;
	  R__b >> angleStep;
	  R__b >> distance;
	  R__b >> linecounter;
	  R__b >> linecounterwrite;
	  R__b >> type;
	  R__b >> dmin;
	  R__b >> dmax;
	  R__b.CheckByteCount(R__s, R__c, HMdcCal2ParSim::IsA());
      }
   }
   else
   {
       R__c = R__b.WriteVersion(HMdcCal2ParSim::IsA(), kTRUE);
       HParSet::Streamer(R__b);
       R__b << array;
       R__b << fMdc;
       comment.Streamer(R__b);
       R__b << sector;
       R__b << module;
       R__b << angleDeg;
       R__b << time;
       R__b << time2;
       R__b << finaltime;
       R__b << angleStep;
       R__b << distance;
       R__b << linecounter;
       R__b << linecounterwrite;
       R__b << slopeOutside;
       R__b << type;
       R__b << dmin;
       R__b << dmax;
       R__b.SetByteCount(R__c, kTRUE);
   }
}
 hmdccal2parsim.cc:1
 hmdccal2parsim.cc:2
 hmdccal2parsim.cc:3
 hmdccal2parsim.cc:4
 hmdccal2parsim.cc:5
 hmdccal2parsim.cc:6
 hmdccal2parsim.cc:7
 hmdccal2parsim.cc:8
 hmdccal2parsim.cc:9
 hmdccal2parsim.cc:10
 hmdccal2parsim.cc:11
 hmdccal2parsim.cc:12
 hmdccal2parsim.cc:13
 hmdccal2parsim.cc:14
 hmdccal2parsim.cc:15
 hmdccal2parsim.cc:16
 hmdccal2parsim.cc:17
 hmdccal2parsim.cc:18
 hmdccal2parsim.cc:19
 hmdccal2parsim.cc:20
 hmdccal2parsim.cc:21
 hmdccal2parsim.cc:22
 hmdccal2parsim.cc:23
 hmdccal2parsim.cc:24
 hmdccal2parsim.cc:25
 hmdccal2parsim.cc:26
 hmdccal2parsim.cc:27
 hmdccal2parsim.cc:28
 hmdccal2parsim.cc:29
 hmdccal2parsim.cc:30
 hmdccal2parsim.cc:31
 hmdccal2parsim.cc:32
 hmdccal2parsim.cc:33
 hmdccal2parsim.cc:34
 hmdccal2parsim.cc:35
 hmdccal2parsim.cc:36
 hmdccal2parsim.cc:37
 hmdccal2parsim.cc:38
 hmdccal2parsim.cc:39
 hmdccal2parsim.cc:40
 hmdccal2parsim.cc:41
 hmdccal2parsim.cc:42
 hmdccal2parsim.cc:43
 hmdccal2parsim.cc:44
 hmdccal2parsim.cc:45
 hmdccal2parsim.cc:46
 hmdccal2parsim.cc:47
 hmdccal2parsim.cc:48
 hmdccal2parsim.cc:49
 hmdccal2parsim.cc:50
 hmdccal2parsim.cc:51
 hmdccal2parsim.cc:52
 hmdccal2parsim.cc:53
 hmdccal2parsim.cc:54
 hmdccal2parsim.cc:55
 hmdccal2parsim.cc:56
 hmdccal2parsim.cc:57
 hmdccal2parsim.cc:58
 hmdccal2parsim.cc:59
 hmdccal2parsim.cc:60
 hmdccal2parsim.cc:61
 hmdccal2parsim.cc:62
 hmdccal2parsim.cc:63
 hmdccal2parsim.cc:64
 hmdccal2parsim.cc:65
 hmdccal2parsim.cc:66
 hmdccal2parsim.cc:67
 hmdccal2parsim.cc:68
 hmdccal2parsim.cc:69
 hmdccal2parsim.cc:70
 hmdccal2parsim.cc:71
 hmdccal2parsim.cc:72
 hmdccal2parsim.cc:73
 hmdccal2parsim.cc:74
 hmdccal2parsim.cc:75
 hmdccal2parsim.cc:76
 hmdccal2parsim.cc:77
 hmdccal2parsim.cc:78
 hmdccal2parsim.cc:79
 hmdccal2parsim.cc:80
 hmdccal2parsim.cc:81
 hmdccal2parsim.cc:82
 hmdccal2parsim.cc:83
 hmdccal2parsim.cc:84
 hmdccal2parsim.cc:85
 hmdccal2parsim.cc:86
 hmdccal2parsim.cc:87
 hmdccal2parsim.cc:88
 hmdccal2parsim.cc:89
 hmdccal2parsim.cc:90
 hmdccal2parsim.cc:91
 hmdccal2parsim.cc:92
 hmdccal2parsim.cc:93
 hmdccal2parsim.cc:94
 hmdccal2parsim.cc:95
 hmdccal2parsim.cc:96
 hmdccal2parsim.cc:97
 hmdccal2parsim.cc:98
 hmdccal2parsim.cc:99
 hmdccal2parsim.cc:100
 hmdccal2parsim.cc:101
 hmdccal2parsim.cc:102
 hmdccal2parsim.cc:103
 hmdccal2parsim.cc:104
 hmdccal2parsim.cc:105
 hmdccal2parsim.cc:106
 hmdccal2parsim.cc:107
 hmdccal2parsim.cc:108
 hmdccal2parsim.cc:109
 hmdccal2parsim.cc:110
 hmdccal2parsim.cc:111
 hmdccal2parsim.cc:112
 hmdccal2parsim.cc:113
 hmdccal2parsim.cc:114
 hmdccal2parsim.cc:115
 hmdccal2parsim.cc:116
 hmdccal2parsim.cc:117
 hmdccal2parsim.cc:118
 hmdccal2parsim.cc:119
 hmdccal2parsim.cc:120
 hmdccal2parsim.cc:121
 hmdccal2parsim.cc:122
 hmdccal2parsim.cc:123
 hmdccal2parsim.cc:124
 hmdccal2parsim.cc:125
 hmdccal2parsim.cc:126
 hmdccal2parsim.cc:127
 hmdccal2parsim.cc:128
 hmdccal2parsim.cc:129
 hmdccal2parsim.cc:130
 hmdccal2parsim.cc:131
 hmdccal2parsim.cc:132
 hmdccal2parsim.cc:133
 hmdccal2parsim.cc:134
 hmdccal2parsim.cc:135
 hmdccal2parsim.cc:136
 hmdccal2parsim.cc:137
 hmdccal2parsim.cc:138
 hmdccal2parsim.cc:139
 hmdccal2parsim.cc:140
 hmdccal2parsim.cc:141
 hmdccal2parsim.cc:142
 hmdccal2parsim.cc:143
 hmdccal2parsim.cc:144
 hmdccal2parsim.cc:145
 hmdccal2parsim.cc:146
 hmdccal2parsim.cc:147
 hmdccal2parsim.cc:148
 hmdccal2parsim.cc:149
 hmdccal2parsim.cc:150
 hmdccal2parsim.cc:151
 hmdccal2parsim.cc:152
 hmdccal2parsim.cc:153
 hmdccal2parsim.cc:154
 hmdccal2parsim.cc:155
 hmdccal2parsim.cc:156
 hmdccal2parsim.cc:157
 hmdccal2parsim.cc:158
 hmdccal2parsim.cc:159
 hmdccal2parsim.cc:160
 hmdccal2parsim.cc:161
 hmdccal2parsim.cc:162
 hmdccal2parsim.cc:163
 hmdccal2parsim.cc:164
 hmdccal2parsim.cc:165
 hmdccal2parsim.cc:166
 hmdccal2parsim.cc:167
 hmdccal2parsim.cc:168
 hmdccal2parsim.cc:169
 hmdccal2parsim.cc:170
 hmdccal2parsim.cc:171
 hmdccal2parsim.cc:172
 hmdccal2parsim.cc:173
 hmdccal2parsim.cc:174
 hmdccal2parsim.cc:175
 hmdccal2parsim.cc:176
 hmdccal2parsim.cc:177
 hmdccal2parsim.cc:178
 hmdccal2parsim.cc:179
 hmdccal2parsim.cc:180
 hmdccal2parsim.cc:181
 hmdccal2parsim.cc:182
 hmdccal2parsim.cc:183
 hmdccal2parsim.cc:184
 hmdccal2parsim.cc:185
 hmdccal2parsim.cc:186
 hmdccal2parsim.cc:187
 hmdccal2parsim.cc:188
 hmdccal2parsim.cc:189
 hmdccal2parsim.cc:190
 hmdccal2parsim.cc:191
 hmdccal2parsim.cc:192
 hmdccal2parsim.cc:193
 hmdccal2parsim.cc:194
 hmdccal2parsim.cc:195
 hmdccal2parsim.cc:196
 hmdccal2parsim.cc:197
 hmdccal2parsim.cc:198
 hmdccal2parsim.cc:199
 hmdccal2parsim.cc:200
 hmdccal2parsim.cc:201
 hmdccal2parsim.cc:202
 hmdccal2parsim.cc:203
 hmdccal2parsim.cc:204
 hmdccal2parsim.cc:205
 hmdccal2parsim.cc:206
 hmdccal2parsim.cc:207
 hmdccal2parsim.cc:208
 hmdccal2parsim.cc:209
 hmdccal2parsim.cc:210
 hmdccal2parsim.cc:211
 hmdccal2parsim.cc:212
 hmdccal2parsim.cc:213
 hmdccal2parsim.cc:214
 hmdccal2parsim.cc:215
 hmdccal2parsim.cc:216
 hmdccal2parsim.cc:217
 hmdccal2parsim.cc:218
 hmdccal2parsim.cc:219
 hmdccal2parsim.cc:220
 hmdccal2parsim.cc:221
 hmdccal2parsim.cc:222
 hmdccal2parsim.cc:223
 hmdccal2parsim.cc:224
 hmdccal2parsim.cc:225
 hmdccal2parsim.cc:226
 hmdccal2parsim.cc:227
 hmdccal2parsim.cc:228
 hmdccal2parsim.cc:229
 hmdccal2parsim.cc:230
 hmdccal2parsim.cc:231
 hmdccal2parsim.cc:232
 hmdccal2parsim.cc:233
 hmdccal2parsim.cc:234
 hmdccal2parsim.cc:235
 hmdccal2parsim.cc:236
 hmdccal2parsim.cc:237
 hmdccal2parsim.cc:238
 hmdccal2parsim.cc:239
 hmdccal2parsim.cc:240
 hmdccal2parsim.cc:241
 hmdccal2parsim.cc:242
 hmdccal2parsim.cc:243
 hmdccal2parsim.cc:244
 hmdccal2parsim.cc:245
 hmdccal2parsim.cc:246
 hmdccal2parsim.cc:247
 hmdccal2parsim.cc:248
 hmdccal2parsim.cc:249
 hmdccal2parsim.cc:250
 hmdccal2parsim.cc:251
 hmdccal2parsim.cc:252
 hmdccal2parsim.cc:253
 hmdccal2parsim.cc:254
 hmdccal2parsim.cc:255
 hmdccal2parsim.cc:256
 hmdccal2parsim.cc:257
 hmdccal2parsim.cc:258
 hmdccal2parsim.cc:259
 hmdccal2parsim.cc:260
 hmdccal2parsim.cc:261
 hmdccal2parsim.cc:262
 hmdccal2parsim.cc:263
 hmdccal2parsim.cc:264
 hmdccal2parsim.cc:265
 hmdccal2parsim.cc:266
 hmdccal2parsim.cc:267
 hmdccal2parsim.cc:268
 hmdccal2parsim.cc:269
 hmdccal2parsim.cc:270
 hmdccal2parsim.cc:271
 hmdccal2parsim.cc:272
 hmdccal2parsim.cc:273
 hmdccal2parsim.cc:274
 hmdccal2parsim.cc:275
 hmdccal2parsim.cc:276
 hmdccal2parsim.cc:277
 hmdccal2parsim.cc:278
 hmdccal2parsim.cc:279
 hmdccal2parsim.cc:280
 hmdccal2parsim.cc:281
 hmdccal2parsim.cc:282
 hmdccal2parsim.cc:283
 hmdccal2parsim.cc:284
 hmdccal2parsim.cc:285
 hmdccal2parsim.cc:286
 hmdccal2parsim.cc:287
 hmdccal2parsim.cc:288
 hmdccal2parsim.cc:289
 hmdccal2parsim.cc:290
 hmdccal2parsim.cc:291
 hmdccal2parsim.cc:292
 hmdccal2parsim.cc:293
 hmdccal2parsim.cc:294
 hmdccal2parsim.cc:295
 hmdccal2parsim.cc:296
 hmdccal2parsim.cc:297
 hmdccal2parsim.cc:298
 hmdccal2parsim.cc:299
 hmdccal2parsim.cc:300
 hmdccal2parsim.cc:301
 hmdccal2parsim.cc:302
 hmdccal2parsim.cc:303
 hmdccal2parsim.cc:304
 hmdccal2parsim.cc:305
 hmdccal2parsim.cc:306
 hmdccal2parsim.cc:307
 hmdccal2parsim.cc:308
 hmdccal2parsim.cc:309
 hmdccal2parsim.cc:310
 hmdccal2parsim.cc:311
 hmdccal2parsim.cc:312
 hmdccal2parsim.cc:313
 hmdccal2parsim.cc:314
 hmdccal2parsim.cc:315
 hmdccal2parsim.cc:316
 hmdccal2parsim.cc:317
 hmdccal2parsim.cc:318
 hmdccal2parsim.cc:319
 hmdccal2parsim.cc:320
 hmdccal2parsim.cc:321
 hmdccal2parsim.cc:322
 hmdccal2parsim.cc:323
 hmdccal2parsim.cc:324
 hmdccal2parsim.cc:325
 hmdccal2parsim.cc:326
 hmdccal2parsim.cc:327
 hmdccal2parsim.cc:328
 hmdccal2parsim.cc:329
 hmdccal2parsim.cc:330
 hmdccal2parsim.cc:331
 hmdccal2parsim.cc:332
 hmdccal2parsim.cc:333
 hmdccal2parsim.cc:334
 hmdccal2parsim.cc:335
 hmdccal2parsim.cc:336
 hmdccal2parsim.cc:337
 hmdccal2parsim.cc:338
 hmdccal2parsim.cc:339
 hmdccal2parsim.cc:340
 hmdccal2parsim.cc:341
 hmdccal2parsim.cc:342
 hmdccal2parsim.cc:343
 hmdccal2parsim.cc:344
 hmdccal2parsim.cc:345
 hmdccal2parsim.cc:346
 hmdccal2parsim.cc:347
 hmdccal2parsim.cc:348
 hmdccal2parsim.cc:349
 hmdccal2parsim.cc:350
 hmdccal2parsim.cc:351
 hmdccal2parsim.cc:352
 hmdccal2parsim.cc:353
 hmdccal2parsim.cc:354
 hmdccal2parsim.cc:355
 hmdccal2parsim.cc:356
 hmdccal2parsim.cc:357
 hmdccal2parsim.cc:358
 hmdccal2parsim.cc:359
 hmdccal2parsim.cc:360
 hmdccal2parsim.cc:361
 hmdccal2parsim.cc:362
 hmdccal2parsim.cc:363
 hmdccal2parsim.cc:364
 hmdccal2parsim.cc:365
 hmdccal2parsim.cc:366
 hmdccal2parsim.cc:367
 hmdccal2parsim.cc:368
 hmdccal2parsim.cc:369
 hmdccal2parsim.cc:370
 hmdccal2parsim.cc:371
 hmdccal2parsim.cc:372
 hmdccal2parsim.cc:373
 hmdccal2parsim.cc:374
 hmdccal2parsim.cc:375
 hmdccal2parsim.cc:376
 hmdccal2parsim.cc:377
 hmdccal2parsim.cc:378
 hmdccal2parsim.cc:379
 hmdccal2parsim.cc:380
 hmdccal2parsim.cc:381
 hmdccal2parsim.cc:382
 hmdccal2parsim.cc:383
 hmdccal2parsim.cc:384
 hmdccal2parsim.cc:385
 hmdccal2parsim.cc:386
 hmdccal2parsim.cc:387
 hmdccal2parsim.cc:388
 hmdccal2parsim.cc:389
 hmdccal2parsim.cc:390
 hmdccal2parsim.cc:391
 hmdccal2parsim.cc:392
 hmdccal2parsim.cc:393
 hmdccal2parsim.cc:394
 hmdccal2parsim.cc:395
 hmdccal2parsim.cc:396
 hmdccal2parsim.cc:397
 hmdccal2parsim.cc:398
 hmdccal2parsim.cc:399
 hmdccal2parsim.cc:400
 hmdccal2parsim.cc:401
 hmdccal2parsim.cc:402
 hmdccal2parsim.cc:403
 hmdccal2parsim.cc:404
 hmdccal2parsim.cc:405
 hmdccal2parsim.cc:406
 hmdccal2parsim.cc:407
 hmdccal2parsim.cc:408
 hmdccal2parsim.cc:409
 hmdccal2parsim.cc:410
 hmdccal2parsim.cc:411
 hmdccal2parsim.cc:412
 hmdccal2parsim.cc:413
 hmdccal2parsim.cc:414
 hmdccal2parsim.cc:415
 hmdccal2parsim.cc:416
 hmdccal2parsim.cc:417
 hmdccal2parsim.cc:418
 hmdccal2parsim.cc:419
 hmdccal2parsim.cc:420
 hmdccal2parsim.cc:421
 hmdccal2parsim.cc:422
 hmdccal2parsim.cc:423
 hmdccal2parsim.cc:424
 hmdccal2parsim.cc:425
 hmdccal2parsim.cc:426
 hmdccal2parsim.cc:427
 hmdccal2parsim.cc:428
 hmdccal2parsim.cc:429
 hmdccal2parsim.cc:430
 hmdccal2parsim.cc:431
 hmdccal2parsim.cc:432
 hmdccal2parsim.cc:433
 hmdccal2parsim.cc:434
 hmdccal2parsim.cc:435
 hmdccal2parsim.cc:436
 hmdccal2parsim.cc:437
 hmdccal2parsim.cc:438
 hmdccal2parsim.cc:439
 hmdccal2parsim.cc:440
 hmdccal2parsim.cc:441
 hmdccal2parsim.cc:442
 hmdccal2parsim.cc:443
 hmdccal2parsim.cc:444
 hmdccal2parsim.cc:445
 hmdccal2parsim.cc:446
 hmdccal2parsim.cc:447
 hmdccal2parsim.cc:448
 hmdccal2parsim.cc:449
 hmdccal2parsim.cc:450
 hmdccal2parsim.cc:451
 hmdccal2parsim.cc:452
 hmdccal2parsim.cc:453
 hmdccal2parsim.cc:454
 hmdccal2parsim.cc:455
 hmdccal2parsim.cc:456
 hmdccal2parsim.cc:457
 hmdccal2parsim.cc:458
 hmdccal2parsim.cc:459
 hmdccal2parsim.cc:460
 hmdccal2parsim.cc:461
 hmdccal2parsim.cc:462
 hmdccal2parsim.cc:463
 hmdccal2parsim.cc:464
 hmdccal2parsim.cc:465
 hmdccal2parsim.cc:466
 hmdccal2parsim.cc:467
 hmdccal2parsim.cc:468
 hmdccal2parsim.cc:469
 hmdccal2parsim.cc:470
 hmdccal2parsim.cc:471
 hmdccal2parsim.cc:472
 hmdccal2parsim.cc:473
 hmdccal2parsim.cc:474
 hmdccal2parsim.cc:475
 hmdccal2parsim.cc:476
 hmdccal2parsim.cc:477
 hmdccal2parsim.cc:478
 hmdccal2parsim.cc:479
 hmdccal2parsim.cc:480
 hmdccal2parsim.cc:481
 hmdccal2parsim.cc:482
 hmdccal2parsim.cc:483
 hmdccal2parsim.cc:484
 hmdccal2parsim.cc:485
 hmdccal2parsim.cc:486
 hmdccal2parsim.cc:487
 hmdccal2parsim.cc:488
 hmdccal2parsim.cc:489
 hmdccal2parsim.cc:490
 hmdccal2parsim.cc:491
 hmdccal2parsim.cc:492
 hmdccal2parsim.cc:493
 hmdccal2parsim.cc:494
 hmdccal2parsim.cc:495
 hmdccal2parsim.cc:496
 hmdccal2parsim.cc:497
 hmdccal2parsim.cc:498
 hmdccal2parsim.cc:499
 hmdccal2parsim.cc:500
 hmdccal2parsim.cc:501
 hmdccal2parsim.cc:502
 hmdccal2parsim.cc:503
 hmdccal2parsim.cc:504
 hmdccal2parsim.cc:505
 hmdccal2parsim.cc:506
 hmdccal2parsim.cc:507
 hmdccal2parsim.cc:508
 hmdccal2parsim.cc:509
 hmdccal2parsim.cc:510
 hmdccal2parsim.cc:511
 hmdccal2parsim.cc:512
 hmdccal2parsim.cc:513
 hmdccal2parsim.cc:514
 hmdccal2parsim.cc:515
 hmdccal2parsim.cc:516
 hmdccal2parsim.cc:517
 hmdccal2parsim.cc:518
 hmdccal2parsim.cc:519
 hmdccal2parsim.cc:520
 hmdccal2parsim.cc:521
 hmdccal2parsim.cc:522
 hmdccal2parsim.cc:523
 hmdccal2parsim.cc:524
 hmdccal2parsim.cc:525
 hmdccal2parsim.cc:526
 hmdccal2parsim.cc:527
 hmdccal2parsim.cc:528
 hmdccal2parsim.cc:529
 hmdccal2parsim.cc:530
 hmdccal2parsim.cc:531
 hmdccal2parsim.cc:532
 hmdccal2parsim.cc:533
 hmdccal2parsim.cc:534
 hmdccal2parsim.cc:535
 hmdccal2parsim.cc:536
 hmdccal2parsim.cc:537
 hmdccal2parsim.cc:538
 hmdccal2parsim.cc:539
 hmdccal2parsim.cc:540
 hmdccal2parsim.cc:541
 hmdccal2parsim.cc:542
 hmdccal2parsim.cc:543
 hmdccal2parsim.cc:544
 hmdccal2parsim.cc:545
 hmdccal2parsim.cc:546
 hmdccal2parsim.cc:547
 hmdccal2parsim.cc:548
 hmdccal2parsim.cc:549
 hmdccal2parsim.cc:550
 hmdccal2parsim.cc:551
 hmdccal2parsim.cc:552
 hmdccal2parsim.cc:553
 hmdccal2parsim.cc:554
 hmdccal2parsim.cc:555
 hmdccal2parsim.cc:556
 hmdccal2parsim.cc:557
 hmdccal2parsim.cc:558
 hmdccal2parsim.cc:559
 hmdccal2parsim.cc:560
 hmdccal2parsim.cc:561
 hmdccal2parsim.cc:562
 hmdccal2parsim.cc:563
 hmdccal2parsim.cc:564
 hmdccal2parsim.cc:565
 hmdccal2parsim.cc:566
 hmdccal2parsim.cc:567
 hmdccal2parsim.cc:568
 hmdccal2parsim.cc:569
 hmdccal2parsim.cc:570
 hmdccal2parsim.cc:571
 hmdccal2parsim.cc:572
 hmdccal2parsim.cc:573
 hmdccal2parsim.cc:574
 hmdccal2parsim.cc:575
 hmdccal2parsim.cc:576
 hmdccal2parsim.cc:577
 hmdccal2parsim.cc:578
 hmdccal2parsim.cc:579
 hmdccal2parsim.cc:580
 hmdccal2parsim.cc:581
 hmdccal2parsim.cc:582
 hmdccal2parsim.cc:583
 hmdccal2parsim.cc:584
 hmdccal2parsim.cc:585
 hmdccal2parsim.cc:586
 hmdccal2parsim.cc:587
 hmdccal2parsim.cc:588
 hmdccal2parsim.cc:589
 hmdccal2parsim.cc:590
 hmdccal2parsim.cc:591
 hmdccal2parsim.cc:592
 hmdccal2parsim.cc:593
 hmdccal2parsim.cc:594
 hmdccal2parsim.cc:595
 hmdccal2parsim.cc:596
 hmdccal2parsim.cc:597
 hmdccal2parsim.cc:598
 hmdccal2parsim.cc:599
 hmdccal2parsim.cc:600
 hmdccal2parsim.cc:601
 hmdccal2parsim.cc:602
 hmdccal2parsim.cc:603
 hmdccal2parsim.cc:604
 hmdccal2parsim.cc:605
 hmdccal2parsim.cc:606
 hmdccal2parsim.cc:607
 hmdccal2parsim.cc:608
 hmdccal2parsim.cc:609
 hmdccal2parsim.cc:610
 hmdccal2parsim.cc:611
 hmdccal2parsim.cc:612
 hmdccal2parsim.cc:613
 hmdccal2parsim.cc:614
 hmdccal2parsim.cc:615
 hmdccal2parsim.cc:616
 hmdccal2parsim.cc:617
 hmdccal2parsim.cc:618
 hmdccal2parsim.cc:619
 hmdccal2parsim.cc:620
 hmdccal2parsim.cc:621
 hmdccal2parsim.cc:622
 hmdccal2parsim.cc:623
 hmdccal2parsim.cc:624
 hmdccal2parsim.cc:625
 hmdccal2parsim.cc:626
 hmdccal2parsim.cc:627
 hmdccal2parsim.cc:628
 hmdccal2parsim.cc:629
 hmdccal2parsim.cc:630
 hmdccal2parsim.cc:631
 hmdccal2parsim.cc:632
 hmdccal2parsim.cc:633
 hmdccal2parsim.cc:634
 hmdccal2parsim.cc:635
 hmdccal2parsim.cc:636
 hmdccal2parsim.cc:637
 hmdccal2parsim.cc:638
 hmdccal2parsim.cc:639
 hmdccal2parsim.cc:640
 hmdccal2parsim.cc:641
 hmdccal2parsim.cc:642
 hmdccal2parsim.cc:643
 hmdccal2parsim.cc:644
 hmdccal2parsim.cc:645
 hmdccal2parsim.cc:646
 hmdccal2parsim.cc:647
 hmdccal2parsim.cc:648
 hmdccal2parsim.cc:649
 hmdccal2parsim.cc:650
 hmdccal2parsim.cc:651
 hmdccal2parsim.cc:652
 hmdccal2parsim.cc:653
 hmdccal2parsim.cc:654
 hmdccal2parsim.cc:655
 hmdccal2parsim.cc:656
 hmdccal2parsim.cc:657
 hmdccal2parsim.cc:658
 hmdccal2parsim.cc:659
 hmdccal2parsim.cc:660
 hmdccal2parsim.cc:661
 hmdccal2parsim.cc:662
 hmdccal2parsim.cc:663
 hmdccal2parsim.cc:664
 hmdccal2parsim.cc:665
 hmdccal2parsim.cc:666
 hmdccal2parsim.cc:667
 hmdccal2parsim.cc:668
 hmdccal2parsim.cc:669
 hmdccal2parsim.cc:670
 hmdccal2parsim.cc:671
 hmdccal2parsim.cc:672
 hmdccal2parsim.cc:673
 hmdccal2parsim.cc:674
 hmdccal2parsim.cc:675
 hmdccal2parsim.cc:676
 hmdccal2parsim.cc:677
 hmdccal2parsim.cc:678
 hmdccal2parsim.cc:679
 hmdccal2parsim.cc:680
 hmdccal2parsim.cc:681
 hmdccal2parsim.cc:682
 hmdccal2parsim.cc:683
 hmdccal2parsim.cc:684
 hmdccal2parsim.cc:685
 hmdccal2parsim.cc:686
 hmdccal2parsim.cc:687
 hmdccal2parsim.cc:688
 hmdccal2parsim.cc:689
 hmdccal2parsim.cc:690
 hmdccal2parsim.cc:691
 hmdccal2parsim.cc:692
 hmdccal2parsim.cc:693
 hmdccal2parsim.cc:694
 hmdccal2parsim.cc:695
 hmdccal2parsim.cc:696
 hmdccal2parsim.cc:697
 hmdccal2parsim.cc:698
 hmdccal2parsim.cc:699
 hmdccal2parsim.cc:700
 hmdccal2parsim.cc:701
 hmdccal2parsim.cc:702
 hmdccal2parsim.cc:703
 hmdccal2parsim.cc:704
 hmdccal2parsim.cc:705
 hmdccal2parsim.cc:706
 hmdccal2parsim.cc:707
 hmdccal2parsim.cc:708
 hmdccal2parsim.cc:709
 hmdccal2parsim.cc:710
 hmdccal2parsim.cc:711
 hmdccal2parsim.cc:712
 hmdccal2parsim.cc:713
 hmdccal2parsim.cc:714
 hmdccal2parsim.cc:715
 hmdccal2parsim.cc:716
 hmdccal2parsim.cc:717
 hmdccal2parsim.cc:718
 hmdccal2parsim.cc:719
 hmdccal2parsim.cc:720
 hmdccal2parsim.cc:721
 hmdccal2parsim.cc:722
 hmdccal2parsim.cc:723
 hmdccal2parsim.cc:724
 hmdccal2parsim.cc:725
 hmdccal2parsim.cc:726
 hmdccal2parsim.cc:727
 hmdccal2parsim.cc:728
 hmdccal2parsim.cc:729
 hmdccal2parsim.cc:730
 hmdccal2parsim.cc:731
 hmdccal2parsim.cc:732
 hmdccal2parsim.cc:733
 hmdccal2parsim.cc:734
 hmdccal2parsim.cc:735
 hmdccal2parsim.cc:736
 hmdccal2parsim.cc:737
 hmdccal2parsim.cc:738
 hmdccal2parsim.cc:739
 hmdccal2parsim.cc:740
 hmdccal2parsim.cc:741
 hmdccal2parsim.cc:742
 hmdccal2parsim.cc:743
 hmdccal2parsim.cc:744
 hmdccal2parsim.cc:745
 hmdccal2parsim.cc:746
 hmdccal2parsim.cc:747
 hmdccal2parsim.cc:748
 hmdccal2parsim.cc:749
 hmdccal2parsim.cc:750
 hmdccal2parsim.cc:751
 hmdccal2parsim.cc:752
 hmdccal2parsim.cc:753
 hmdccal2parsim.cc:754
 hmdccal2parsim.cc:755
 hmdccal2parsim.cc:756
 hmdccal2parsim.cc:757
 hmdccal2parsim.cc:758
 hmdccal2parsim.cc:759
 hmdccal2parsim.cc:760
 hmdccal2parsim.cc:761
 hmdccal2parsim.cc:762
 hmdccal2parsim.cc:763
 hmdccal2parsim.cc:764
 hmdccal2parsim.cc:765
 hmdccal2parsim.cc:766
 hmdccal2parsim.cc:767
 hmdccal2parsim.cc:768
 hmdccal2parsim.cc:769
 hmdccal2parsim.cc:770
 hmdccal2parsim.cc:771
 hmdccal2parsim.cc:772
 hmdccal2parsim.cc:773
 hmdccal2parsim.cc:774
 hmdccal2parsim.cc:775
 hmdccal2parsim.cc:776
 hmdccal2parsim.cc:777
 hmdccal2parsim.cc:778
 hmdccal2parsim.cc:779
 hmdccal2parsim.cc:780
 hmdccal2parsim.cc:781
 hmdccal2parsim.cc:782
 hmdccal2parsim.cc:783
 hmdccal2parsim.cc:784
 hmdccal2parsim.cc:785
 hmdccal2parsim.cc:786
 hmdccal2parsim.cc:787
 hmdccal2parsim.cc:788
 hmdccal2parsim.cc:789
 hmdccal2parsim.cc:790
 hmdccal2parsim.cc:791
 hmdccal2parsim.cc:792
 hmdccal2parsim.cc:793
 hmdccal2parsim.cc:794
 hmdccal2parsim.cc:795
 hmdccal2parsim.cc:796
 hmdccal2parsim.cc:797
 hmdccal2parsim.cc:798
 hmdccal2parsim.cc:799
 hmdccal2parsim.cc:800
 hmdccal2parsim.cc:801
 hmdccal2parsim.cc:802
 hmdccal2parsim.cc:803
 hmdccal2parsim.cc:804
 hmdccal2parsim.cc:805
 hmdccal2parsim.cc:806
 hmdccal2parsim.cc:807
 hmdccal2parsim.cc:808
 hmdccal2parsim.cc:809
 hmdccal2parsim.cc:810
 hmdccal2parsim.cc:811
 hmdccal2parsim.cc:812
 hmdccal2parsim.cc:813
 hmdccal2parsim.cc:814
 hmdccal2parsim.cc:815
 hmdccal2parsim.cc:816
 hmdccal2parsim.cc:817
 hmdccal2parsim.cc:818
 hmdccal2parsim.cc:819
 hmdccal2parsim.cc:820
 hmdccal2parsim.cc:821
 hmdccal2parsim.cc:822
 hmdccal2parsim.cc:823
 hmdccal2parsim.cc:824
 hmdccal2parsim.cc:825
 hmdccal2parsim.cc:826
 hmdccal2parsim.cc:827
 hmdccal2parsim.cc:828
 hmdccal2parsim.cc:829
 hmdccal2parsim.cc:830
 hmdccal2parsim.cc:831
 hmdccal2parsim.cc:832
 hmdccal2parsim.cc:833
 hmdccal2parsim.cc:834
 hmdccal2parsim.cc:835
 hmdccal2parsim.cc:836
 hmdccal2parsim.cc:837
 hmdccal2parsim.cc:838
 hmdccal2parsim.cc:839
 hmdccal2parsim.cc:840
 hmdccal2parsim.cc:841
 hmdccal2parsim.cc:842
 hmdccal2parsim.cc:843
 hmdccal2parsim.cc:844
 hmdccal2parsim.cc:845
 hmdccal2parsim.cc:846
 hmdccal2parsim.cc:847
 hmdccal2parsim.cc:848
 hmdccal2parsim.cc:849
 hmdccal2parsim.cc:850
 hmdccal2parsim.cc:851
 hmdccal2parsim.cc:852
 hmdccal2parsim.cc:853
 hmdccal2parsim.cc:854
 hmdccal2parsim.cc:855
 hmdccal2parsim.cc:856
 hmdccal2parsim.cc:857
 hmdccal2parsim.cc:858
 hmdccal2parsim.cc:859
 hmdccal2parsim.cc:860
 hmdccal2parsim.cc:861
 hmdccal2parsim.cc:862
 hmdccal2parsim.cc:863
 hmdccal2parsim.cc:864
 hmdccal2parsim.cc:865
 hmdccal2parsim.cc:866
 hmdccal2parsim.cc:867
 hmdccal2parsim.cc:868
 hmdccal2parsim.cc:869
 hmdccal2parsim.cc:870
 hmdccal2parsim.cc:871
 hmdccal2parsim.cc:872
 hmdccal2parsim.cc:873
 hmdccal2parsim.cc:874
 hmdccal2parsim.cc:875
 hmdccal2parsim.cc:876
 hmdccal2parsim.cc:877
 hmdccal2parsim.cc:878
 hmdccal2parsim.cc:879
 hmdccal2parsim.cc:880
 hmdccal2parsim.cc:881
 hmdccal2parsim.cc:882
 hmdccal2parsim.cc:883
 hmdccal2parsim.cc:884
 hmdccal2parsim.cc:885
 hmdccal2parsim.cc:886
 hmdccal2parsim.cc:887
 hmdccal2parsim.cc:888
 hmdccal2parsim.cc:889
 hmdccal2parsim.cc:890
 hmdccal2parsim.cc:891
 hmdccal2parsim.cc:892
 hmdccal2parsim.cc:893
 hmdccal2parsim.cc:894
 hmdccal2parsim.cc:895
 hmdccal2parsim.cc:896
 hmdccal2parsim.cc:897
 hmdccal2parsim.cc:898
 hmdccal2parsim.cc:899
 hmdccal2parsim.cc:900
 hmdccal2parsim.cc:901
 hmdccal2parsim.cc:902
 hmdccal2parsim.cc:903
 hmdccal2parsim.cc:904
 hmdccal2parsim.cc:905
 hmdccal2parsim.cc:906
 hmdccal2parsim.cc:907
 hmdccal2parsim.cc:908
 hmdccal2parsim.cc:909
 hmdccal2parsim.cc:910
 hmdccal2parsim.cc:911
 hmdccal2parsim.cc:912
 hmdccal2parsim.cc:913
 hmdccal2parsim.cc:914
 hmdccal2parsim.cc:915
 hmdccal2parsim.cc:916
 hmdccal2parsim.cc:917
 hmdccal2parsim.cc:918
 hmdccal2parsim.cc:919
 hmdccal2parsim.cc:920
 hmdccal2parsim.cc:921
 hmdccal2parsim.cc:922
 hmdccal2parsim.cc:923
 hmdccal2parsim.cc:924
 hmdccal2parsim.cc:925
 hmdccal2parsim.cc:926
 hmdccal2parsim.cc:927
 hmdccal2parsim.cc:928
 hmdccal2parsim.cc:929
 hmdccal2parsim.cc:930
 hmdccal2parsim.cc:931
 hmdccal2parsim.cc:932
 hmdccal2parsim.cc:933
 hmdccal2parsim.cc:934
 hmdccal2parsim.cc:935
 hmdccal2parsim.cc:936
 hmdccal2parsim.cc:937
 hmdccal2parsim.cc:938
 hmdccal2parsim.cc:939
 hmdccal2parsim.cc:940
 hmdccal2parsim.cc:941
 hmdccal2parsim.cc:942
 hmdccal2parsim.cc:943
 hmdccal2parsim.cc:944
 hmdccal2parsim.cc:945
 hmdccal2parsim.cc:946
 hmdccal2parsim.cc:947
 hmdccal2parsim.cc:948
 hmdccal2parsim.cc:949
 hmdccal2parsim.cc:950
 hmdccal2parsim.cc:951
 hmdccal2parsim.cc:952
 hmdccal2parsim.cc:953
 hmdccal2parsim.cc:954
 hmdccal2parsim.cc:955
 hmdccal2parsim.cc:956
 hmdccal2parsim.cc:957
 hmdccal2parsim.cc:958
 hmdccal2parsim.cc:959
 hmdccal2parsim.cc:960
 hmdccal2parsim.cc:961
 hmdccal2parsim.cc:962
 hmdccal2parsim.cc:963
 hmdccal2parsim.cc:964
 hmdccal2parsim.cc:965
 hmdccal2parsim.cc:966
 hmdccal2parsim.cc:967
 hmdccal2parsim.cc:968
 hmdccal2parsim.cc:969
 hmdccal2parsim.cc:970
 hmdccal2parsim.cc:971
 hmdccal2parsim.cc:972
 hmdccal2parsim.cc:973
 hmdccal2parsim.cc:974
 hmdccal2parsim.cc:975
 hmdccal2parsim.cc:976
 hmdccal2parsim.cc:977
 hmdccal2parsim.cc:978
 hmdccal2parsim.cc:979
 hmdccal2parsim.cc:980
 hmdccal2parsim.cc:981
 hmdccal2parsim.cc:982
 hmdccal2parsim.cc:983
 hmdccal2parsim.cc:984
 hmdccal2parsim.cc:985
 hmdccal2parsim.cc:986
 hmdccal2parsim.cc:987
 hmdccal2parsim.cc:988
 hmdccal2parsim.cc:989
 hmdccal2parsim.cc:990
 hmdccal2parsim.cc:991
 hmdccal2parsim.cc:992
 hmdccal2parsim.cc:993
 hmdccal2parsim.cc:994
 hmdccal2parsim.cc:995
 hmdccal2parsim.cc:996
 hmdccal2parsim.cc:997
 hmdccal2parsim.cc:998
 hmdccal2parsim.cc:999
 hmdccal2parsim.cc:1000
 hmdccal2parsim.cc:1001
 hmdccal2parsim.cc:1002
 hmdccal2parsim.cc:1003
 hmdccal2parsim.cc:1004
 hmdccal2parsim.cc:1005
 hmdccal2parsim.cc:1006
 hmdccal2parsim.cc:1007
 hmdccal2parsim.cc:1008
 hmdccal2parsim.cc:1009
 hmdccal2parsim.cc:1010
 hmdccal2parsim.cc:1011
 hmdccal2parsim.cc:1012
 hmdccal2parsim.cc:1013
 hmdccal2parsim.cc:1014
 hmdccal2parsim.cc:1015
 hmdccal2parsim.cc:1016
 hmdccal2parsim.cc:1017
 hmdccal2parsim.cc:1018
 hmdccal2parsim.cc:1019
 hmdccal2parsim.cc:1020
 hmdccal2parsim.cc:1021
 hmdccal2parsim.cc:1022
 hmdccal2parsim.cc:1023
 hmdccal2parsim.cc:1024
 hmdccal2parsim.cc:1025
 hmdccal2parsim.cc:1026
 hmdccal2parsim.cc:1027
 hmdccal2parsim.cc:1028
 hmdccal2parsim.cc:1029
 hmdccal2parsim.cc:1030
 hmdccal2parsim.cc:1031
 hmdccal2parsim.cc:1032
 hmdccal2parsim.cc:1033
 hmdccal2parsim.cc:1034
 hmdccal2parsim.cc:1035
 hmdccal2parsim.cc:1036
 hmdccal2parsim.cc:1037
 hmdccal2parsim.cc:1038
 hmdccal2parsim.cc:1039
 hmdccal2parsim.cc:1040
 hmdccal2parsim.cc:1041
 hmdccal2parsim.cc:1042
 hmdccal2parsim.cc:1043
 hmdccal2parsim.cc:1044
 hmdccal2parsim.cc:1045
 hmdccal2parsim.cc:1046
 hmdccal2parsim.cc:1047
 hmdccal2parsim.cc:1048
 hmdccal2parsim.cc:1049
 hmdccal2parsim.cc:1050
 hmdccal2parsim.cc:1051
 hmdccal2parsim.cc:1052
 hmdccal2parsim.cc:1053
 hmdccal2parsim.cc:1054
 hmdccal2parsim.cc:1055
 hmdccal2parsim.cc:1056
 hmdccal2parsim.cc:1057
 hmdccal2parsim.cc:1058
 hmdccal2parsim.cc:1059
 hmdccal2parsim.cc:1060
 hmdccal2parsim.cc:1061
 hmdccal2parsim.cc:1062
 hmdccal2parsim.cc:1063
 hmdccal2parsim.cc:1064
 hmdccal2parsim.cc:1065
 hmdccal2parsim.cc:1066
 hmdccal2parsim.cc:1067
 hmdccal2parsim.cc:1068
 hmdccal2parsim.cc:1069
 hmdccal2parsim.cc:1070
 hmdccal2parsim.cc:1071
 hmdccal2parsim.cc:1072
 hmdccal2parsim.cc:1073
 hmdccal2parsim.cc:1074
 hmdccal2parsim.cc:1075
 hmdccal2parsim.cc:1076
 hmdccal2parsim.cc:1077
 hmdccal2parsim.cc:1078
 hmdccal2parsim.cc:1079
 hmdccal2parsim.cc:1080
 hmdccal2parsim.cc:1081
 hmdccal2parsim.cc:1082
 hmdccal2parsim.cc:1083
 hmdccal2parsim.cc:1084
 hmdccal2parsim.cc:1085
 hmdccal2parsim.cc:1086
 hmdccal2parsim.cc:1087
 hmdccal2parsim.cc:1088
 hmdccal2parsim.cc:1089
 hmdccal2parsim.cc:1090
 hmdccal2parsim.cc:1091
 hmdccal2parsim.cc:1092
 hmdccal2parsim.cc:1093
 hmdccal2parsim.cc:1094
 hmdccal2parsim.cc:1095
 hmdccal2parsim.cc:1096
 hmdccal2parsim.cc:1097
 hmdccal2parsim.cc:1098
 hmdccal2parsim.cc:1099
 hmdccal2parsim.cc:1100
 hmdccal2parsim.cc:1101
 hmdccal2parsim.cc:1102
 hmdccal2parsim.cc:1103
 hmdccal2parsim.cc:1104
 hmdccal2parsim.cc:1105
 hmdccal2parsim.cc:1106
 hmdccal2parsim.cc:1107
 hmdccal2parsim.cc:1108
 hmdccal2parsim.cc:1109
 hmdccal2parsim.cc:1110
 hmdccal2parsim.cc:1111
 hmdccal2parsim.cc:1112
 hmdccal2parsim.cc:1113
 hmdccal2parsim.cc:1114
 hmdccal2parsim.cc:1115
 hmdccal2parsim.cc:1116
 hmdccal2parsim.cc:1117
 hmdccal2parsim.cc:1118
 hmdccal2parsim.cc:1119
 hmdccal2parsim.cc:1120
 hmdccal2parsim.cc:1121
 hmdccal2parsim.cc:1122
 hmdccal2parsim.cc:1123
 hmdccal2parsim.cc:1124
 hmdccal2parsim.cc:1125
 hmdccal2parsim.cc:1126
 hmdccal2parsim.cc:1127
 hmdccal2parsim.cc:1128
 hmdccal2parsim.cc:1129
 hmdccal2parsim.cc:1130
 hmdccal2parsim.cc:1131
 hmdccal2parsim.cc:1132
 hmdccal2parsim.cc:1133
 hmdccal2parsim.cc:1134
 hmdccal2parsim.cc:1135
 hmdccal2parsim.cc:1136
 hmdccal2parsim.cc:1137
 hmdccal2parsim.cc:1138
 hmdccal2parsim.cc:1139
 hmdccal2parsim.cc:1140
 hmdccal2parsim.cc:1141
 hmdccal2parsim.cc:1142
 hmdccal2parsim.cc:1143
 hmdccal2parsim.cc:1144
 hmdccal2parsim.cc:1145
 hmdccal2parsim.cc:1146
 hmdccal2parsim.cc:1147
 hmdccal2parsim.cc:1148
 hmdccal2parsim.cc:1149
 hmdccal2parsim.cc:1150
 hmdccal2parsim.cc:1151
 hmdccal2parsim.cc:1152
 hmdccal2parsim.cc:1153
 hmdccal2parsim.cc:1154
 hmdccal2parsim.cc:1155
 hmdccal2parsim.cc:1156
 hmdccal2parsim.cc:1157
 hmdccal2parsim.cc:1158
 hmdccal2parsim.cc:1159
 hmdccal2parsim.cc:1160
 hmdccal2parsim.cc:1161
 hmdccal2parsim.cc:1162
 hmdccal2parsim.cc:1163
 hmdccal2parsim.cc:1164
 hmdccal2parsim.cc:1165
 hmdccal2parsim.cc:1166
 hmdccal2parsim.cc:1167
 hmdccal2parsim.cc:1168
 hmdccal2parsim.cc:1169
 hmdccal2parsim.cc:1170
 hmdccal2parsim.cc:1171
 hmdccal2parsim.cc:1172
 hmdccal2parsim.cc:1173
 hmdccal2parsim.cc:1174
 hmdccal2parsim.cc:1175
 hmdccal2parsim.cc:1176
 hmdccal2parsim.cc:1177
 hmdccal2parsim.cc:1178
 hmdccal2parsim.cc:1179
 hmdccal2parsim.cc:1180
 hmdccal2parsim.cc:1181
 hmdccal2parsim.cc:1182
 hmdccal2parsim.cc:1183
 hmdccal2parsim.cc:1184
 hmdccal2parsim.cc:1185
 hmdccal2parsim.cc:1186
 hmdccal2parsim.cc:1187
 hmdccal2parsim.cc:1188
 hmdccal2parsim.cc:1189
 hmdccal2parsim.cc:1190
 hmdccal2parsim.cc:1191
 hmdccal2parsim.cc:1192
 hmdccal2parsim.cc:1193
 hmdccal2parsim.cc:1194
 hmdccal2parsim.cc:1195
 hmdccal2parsim.cc:1196
 hmdccal2parsim.cc:1197
 hmdccal2parsim.cc:1198
 hmdccal2parsim.cc:1199
 hmdccal2parsim.cc:1200
 hmdccal2parsim.cc:1201
 hmdccal2parsim.cc:1202
 hmdccal2parsim.cc:1203
 hmdccal2parsim.cc:1204
 hmdccal2parsim.cc:1205
 hmdccal2parsim.cc:1206
 hmdccal2parsim.cc:1207
 hmdccal2parsim.cc:1208
 hmdccal2parsim.cc:1209
 hmdccal2parsim.cc:1210
 hmdccal2parsim.cc:1211
 hmdccal2parsim.cc:1212
 hmdccal2parsim.cc:1213
 hmdccal2parsim.cc:1214
 hmdccal2parsim.cc:1215
 hmdccal2parsim.cc:1216
 hmdccal2parsim.cc:1217
 hmdccal2parsim.cc:1218
 hmdccal2parsim.cc:1219
 hmdccal2parsim.cc:1220
 hmdccal2parsim.cc:1221
 hmdccal2parsim.cc:1222
 hmdccal2parsim.cc:1223
 hmdccal2parsim.cc:1224
 hmdccal2parsim.cc:1225
 hmdccal2parsim.cc:1226
 hmdccal2parsim.cc:1227
 hmdccal2parsim.cc:1228
 hmdccal2parsim.cc:1229
 hmdccal2parsim.cc:1230
 hmdccal2parsim.cc:1231
 hmdccal2parsim.cc:1232
 hmdccal2parsim.cc:1233
 hmdccal2parsim.cc:1234
 hmdccal2parsim.cc:1235
 hmdccal2parsim.cc:1236
 hmdccal2parsim.cc:1237
 hmdccal2parsim.cc:1238
 hmdccal2parsim.cc:1239
 hmdccal2parsim.cc:1240
 hmdccal2parsim.cc:1241
 hmdccal2parsim.cc:1242
 hmdccal2parsim.cc:1243
 hmdccal2parsim.cc:1244
 hmdccal2parsim.cc:1245
 hmdccal2parsim.cc:1246
 hmdccal2parsim.cc:1247
 hmdccal2parsim.cc:1248
 hmdccal2parsim.cc:1249
 hmdccal2parsim.cc:1250
 hmdccal2parsim.cc:1251
 hmdccal2parsim.cc:1252
 hmdccal2parsim.cc:1253
 hmdccal2parsim.cc:1254
 hmdccal2parsim.cc:1255
 hmdccal2parsim.cc:1256
 hmdccal2parsim.cc:1257
 hmdccal2parsim.cc:1258
 hmdccal2parsim.cc:1259
 hmdccal2parsim.cc:1260
 hmdccal2parsim.cc:1261
 hmdccal2parsim.cc:1262
 hmdccal2parsim.cc:1263
 hmdccal2parsim.cc:1264
 hmdccal2parsim.cc:1265
 hmdccal2parsim.cc:1266
 hmdccal2parsim.cc:1267
 hmdccal2parsim.cc:1268
 hmdccal2parsim.cc:1269
 hmdccal2parsim.cc:1270
 hmdccal2parsim.cc:1271
 hmdccal2parsim.cc:1272
 hmdccal2parsim.cc:1273
 hmdccal2parsim.cc:1274
 hmdccal2parsim.cc:1275
 hmdccal2parsim.cc:1276
 hmdccal2parsim.cc:1277
 hmdccal2parsim.cc:1278
 hmdccal2parsim.cc:1279
 hmdccal2parsim.cc:1280
 hmdccal2parsim.cc:1281
 hmdccal2parsim.cc:1282
 hmdccal2parsim.cc:1283
 hmdccal2parsim.cc:1284
 hmdccal2parsim.cc:1285
 hmdccal2parsim.cc:1286
 hmdccal2parsim.cc:1287
 hmdccal2parsim.cc:1288
 hmdccal2parsim.cc:1289
 hmdccal2parsim.cc:1290
 hmdccal2parsim.cc:1291
 hmdccal2parsim.cc:1292
 hmdccal2parsim.cc:1293
 hmdccal2parsim.cc:1294
 hmdccal2parsim.cc:1295
 hmdccal2parsim.cc:1296
 hmdccal2parsim.cc:1297
 hmdccal2parsim.cc:1298
 hmdccal2parsim.cc:1299
 hmdccal2parsim.cc:1300
 hmdccal2parsim.cc:1301
 hmdccal2parsim.cc:1302
 hmdccal2parsim.cc:1303
 hmdccal2parsim.cc:1304
 hmdccal2parsim.cc:1305
 hmdccal2parsim.cc:1306
 hmdccal2parsim.cc:1307
 hmdccal2parsim.cc:1308
 hmdccal2parsim.cc:1309
 hmdccal2parsim.cc:1310
 hmdccal2parsim.cc:1311
 hmdccal2parsim.cc:1312
 hmdccal2parsim.cc:1313
 hmdccal2parsim.cc:1314
 hmdccal2parsim.cc:1315
 hmdccal2parsim.cc:1316
 hmdccal2parsim.cc:1317
 hmdccal2parsim.cc:1318
 hmdccal2parsim.cc:1319
 hmdccal2parsim.cc:1320
 hmdccal2parsim.cc:1321
 hmdccal2parsim.cc:1322
 hmdccal2parsim.cc:1323
 hmdccal2parsim.cc:1324
 hmdccal2parsim.cc:1325
 hmdccal2parsim.cc:1326
 hmdccal2parsim.cc:1327
 hmdccal2parsim.cc:1328
 hmdccal2parsim.cc:1329
 hmdccal2parsim.cc:1330
 hmdccal2parsim.cc:1331
 hmdccal2parsim.cc:1332
 hmdccal2parsim.cc:1333
 hmdccal2parsim.cc:1334
 hmdccal2parsim.cc:1335
 hmdccal2parsim.cc:1336
 hmdccal2parsim.cc:1337
 hmdccal2parsim.cc:1338
 hmdccal2parsim.cc:1339
 hmdccal2parsim.cc:1340