void SimEntity::setInitialPose() {
bool worldAnchor = false;
if(!control) return;
if(config.find("rootNode") != config.end()) {
if(config.find("anchor") != config.end()) {
if((std::string)config["anchor"] == "world") {
worldAnchor = true;
}
}
NodeId id = getNode((std::string)config["rootNode"]);
NodeData myNode = control->nodes->getFullNode(id);
utils::Quaternion tmpQ(1, 0, 0, 0);
utils::Vector tmpV;
if(config.find("position") != config.end()) {
myNode.pos.x() = config["position"][0];
myNode.pos.y() = config["position"][1];
myNode.pos.z() = config["position"][2];
control->nodes->editNode(&myNode, EDIT_NODE_POS | EDIT_NODE_MOVE_ALL);
}
if(config.find("rotation") != config.end()) {
// check if euler angles or quaternion is provided; rotate around z
// if only one angle is provided
switch (config["rotation"].size()) {
case 1: tmpV[0] = 0;
tmpV[1] = 0;
tmpV[2] = config["rotation"][0];
tmpQ = utils::eulerToQuaternion(tmpV);
break;
case 3: tmpV[0] = config["rotation"][0];
tmpV[1] = config["rotation"][1];
tmpV[2] = config["rotation"][2];
tmpQ = utils::eulerToQuaternion(tmpV);
break;
case 4: tmpQ.x() = (sReal)config["rotation"][1];
tmpQ.y() = (sReal)config["rotation"][2];
tmpQ.z() = (sReal)config["rotation"][3];
tmpQ.w() = (sReal)config["rotation"][0];
break;
}
myNode.rot = tmpQ;
control->nodes->editNode(&myNode, EDIT_NODE_ROT | EDIT_NODE_MOVE_ALL);
}
if(worldAnchor) {
control->sim->connectNodes(id, 0);
}
// set Joints
configmaps::ConfigVector::iterator it;
configmaps::ConfigMap::iterator joint_it;
for (it = config["poses"].begin(); it!= config["poses"].end(); ++it) {
if ((std::string)(*it)["name"] == (std::string)config["pose"]) {
for (joint_it = (*it)["joints"][0].children.begin();
joint_it!= (*it)["joints"][0].children.end(); ++joint_it) {
//fprintf(stderr, "setMotorValue: joint: %s, id: %lu, value: %f\n", ((std::string)joint_it->first).c_str(), motorIDMap[joint_it->first], (double)joint_it->second);
control->motors->setMotorValue(getMotor(joint_it->first),
joint_it->second);
}
}
}
}
}
Int_t MakeTrendingITSQA(TString qafilename ="QAresults.root", //full path of the QA output; set IsOnGrid to prepend "alien://"
Int_t runNumber= 133005, // run number
Bool_t isMC=kFALSE, //MC flag, to disable meaningless checks
Bool_t canvasE = kFALSE, //enable display plots on canvas and save png
Bool_t IsOnGrid = kFALSE, //set to kTRUE to access files on the grid
TString ocdbStorage = "raw://") //set the default ocdb storage
{
// macro to generate tree with ITS QA trending variables
// access qa PWGPP output files
if (!qafilename) {
Printf("Error - Invalid input file");
return 1;
}
char defaultQAoutput[30]="QAresults.root";
char * treePostFileName="trending.root";
if (IsOnGrid) TGrid::Connect("alien://");
TFile * fin = TFile::Open(qafilename,"r");
if (!fin) {
Printf("ERROR: QA output not found. Exiting...\n");
return -1;
} else {
Printf("INFO: QA output file %s open. \n",fin->GetName());
}
TFile * trendFile = new TFile(treePostFileName,"recreate");
///// SDD Variables
Int_t nrun,nEvents, nEventsTriggered;
Float_t minDrTime,errminDrTime,meanDrTime,errmeanDrTime;
Float_t fracTrackWithClu1,fracTrackWithClu2,errfracTrackWithClu1,errfracTrackWithClu2;
Float_t fracTrackWithClu3,fracTrackWithClu4,errfracTrackWithClu3,errfracTrackWithClu4;
Float_t fracTrackWithClu5,fracTrackWithClu6,errfracTrackWithClu5,errfracTrackWithClu6;
Float_t fracExtra,errfracExtra;
Float_t fracT[6]={0.,0.,0.,0.,0.,0.};
Float_t efracT[6]={0.,0.,0.,0.,0.,0.};
Int_t nTotEvents;
Int_t nTrigEvents;
Double_t averPoints=0.;
Double_t cntBins=0.;
Float_t minTime=-999.;
Float_t errMinTime=0.;
Float_t MPVdEdxLay3,errMPVdEdxLay3,MPVdEdxLay4,errMPVdEdxLay4;
Float_t MPVdEdxTB0,errMPVdEdxTB0,MPVdEdxTB5,errMPVdEdxTB5;
//// Vertex Variables
Float_t meanVtxTRKx,meanVtxTRKy,meanVtxTRKz;
Float_t meanVtxSPDx,meanVtxSPDy,meanVtxSPDz;
Float_t sigmaVtxTRKx,sigmaVtxTRKy,sigmaVtxTRKz;
Float_t sigmaVtxSPDx,sigmaVtxSPDy,sigmaVtxSPDz;
Float_t meanVtxTRKxErr,meanVtxTRKyErr,meanVtxTRKzErr;
Float_t meanVtxSPDxErr,meanVtxSPDyErr,meanVtxSPDzErr;
Float_t sigmaVtxTRKxErr,sigmaVtxTRKyErr,sigmaVtxTRKzErr;
Float_t sigmaVtxSPDxErr,sigmaVtxSPDyErr,sigmaVtxSPDzErr;
///// SSD Variables
Float_t MPVL5,MPVErrL5;
Float_t MPVL6,MPVErrL6;
Float_t ChargeRatioL5,ChargeRatioErrL5;
Float_t ChargeRatioL6,ChargeRatioErrL6;
Float_t EmptyModulesSDD;
///// Matching Variables
Float_t FracSPD1;
Float_t errFracSPD1;
Float_t FracSPD2;
Float_t errFracSPD2;
Float_t Eff6Pt02;
Float_t errEff6Pt02;
Float_t Eff6Pt1;
Float_t errEff6Pt1;
Float_t Eff6Pt10;
Float_t errEff6Pt10;
Float_t Eff5Pt02;
Float_t errEff5Pt02;
Float_t Eff5Pt1;
Float_t errEff5Pt1;
Float_t Eff5Pt10;
Float_t errEff5Pt10;
Float_t Eff4Pt02;
Float_t errEff4Pt02;
Float_t Eff4Pt1;
Float_t errEff4Pt1;
Float_t Eff4Pt10;
Float_t errEff4Pt10;
Float_t Eff3Pt02;
Float_t errEff3Pt02;
Float_t Eff3Pt1;
Float_t errEff3Pt1;
Float_t Eff3Pt10;
Float_t errEff3Pt10;
Float_t Eff2Pt02;
Float_t errEff2Pt02;
Float_t Eff2Pt1;
Float_t errEff2Pt1;
Float_t Eff2Pt10;
Float_t errEff2Pt10;
Float_t EffSPDPt02;
Float_t errEffSPDPt02;
Float_t EffSPDPt1;
Float_t errEffSPDPt1;
Float_t EffSPDPt10;
Float_t errEffSPDPt10;
Float_t EffoneSPDPt02;
Float_t errEffoneSPDPt02;
Float_t EffoneSPDPt1;
Float_t errEffoneSPDPt1;
Float_t EffoneSPDPt10;
Float_t errEffoneSPDPt10;
Float_t EffTOTPt02;
Float_t errEffTOTPt02;
Float_t EffTOTPt1;
Float_t errEffTOTPt1;
Float_t EffTOTPt10;
Float_t errEffTOTPt10;
TTree * ttree=new TTree("trending","tree of trending variables");
ttree->Branch("nrun",&nrun,"nrun/I");
ttree->Branch("nEvents",&nEvents,"nEvents/I");
ttree->Branch("nEventsTriggered",&nEventsTriggered,"nEventsTriggered/I");
ttree->Branch("minDrTime",&minDrTime,"minDrTime/F");
ttree->Branch("errminDrTime",&errminDrTime,"errminDrTime/F");
ttree->Branch("meanDrTime",&meanDrTime,"meanDrTime/F");
ttree->Branch("errmeanDrTime",&errmeanDrTime,"errmeanDrTime/F"); //mean time
ttree->Branch("fracTrackWithClu1",&fracTrackWithClu1,"fracTrackWithClu1/F"); //fraction of tracks with cluster in layer 1
ttree->Branch("errfracTrackWithClu1",&errfracTrackWithClu1,"errfracTrackWithClu1/F"); //error fraction of tracks with cluster in layer 1
ttree->Branch("fracTrackWithClu2",&fracTrackWithClu2,"fracTrackWithClu2/F"); //
ttree->Branch("errfracTrackWithClu2",&errfracTrackWithClu2,"errfracTrackWithClu2/F"); //
ttree->Branch("fracTrackWithClu3",&fracTrackWithClu3,"fracTrackWithClu3/F");
ttree->Branch("errfracTrackWithClu3",&errfracTrackWithClu3,"errfracTrackWithClu3/F");
ttree->Branch("fracTrackWithClu4",&fracTrackWithClu4,"fracTrackWithClu4/F");
ttree->Branch("errfracTrackWithClu4",&errfracTrackWithClu4,"errfracTrackWithClu4/F");
ttree->Branch("fracTrackWithClu5",&fracTrackWithClu5,"fracTrackWithClu5/F");
ttree->Branch("errfracTrackWithClu5",&errfracTrackWithClu5,"errfracTrackWithClu5/F");
ttree->Branch("fracTrackWithClu6",&fracTrackWithClu6,"fracTrackWithClu6/F");
ttree->Branch("errfracTrackWithClu6",&errfracTrackWithClu6,"errfracTrackWithClu6/F");
ttree->Branch("meanVtxTRKx",&meanVtxTRKx,"meanVtxTRKx/F"); // mean of tracks vertex position - x
ttree->Branch("meanVtxTRKy",&meanVtxTRKy,"meanVtxTRKy/F"); // mean of tracks vertex position - y
ttree->Branch("meanVtxTRKz",&meanVtxTRKz,"meanVtxTRKz/F"); // mean of tracks vertex position - z
ttree->Branch("meanVtxTRKxErr",&meanVtxTRKxErr,"meanVtxTRKxErr/F"); // error mean of tracks vertex position - x
ttree->Branch("meanVtxTRKyErr",&meanVtxTRKyErr,"meanVtxTRKyErr/F"); // error mean of tracks vertex position - y
ttree->Branch("meanVtxTRKzErr",&meanVtxTRKzErr,"meanVtxTRKzErr/F"); // error mean of tracks vertex position - z
ttree->Branch("meanVtxSPDx",&meanVtxSPDx,"meanVtxSPDx/F"); // mean of SPD vertex position - x
ttree->Branch("meanVtxSPDy",&meanVtxSPDy,"meanVtxSPDy/F"); // mean of SPD vertex position - y
ttree->Branch("meanVtxSPDz",&meanVtxSPDz,"meanVtxSPDz/F"); // mean of SPD vertex position - z
ttree->Branch("meanVtxSPDxErr",&meanVtxSPDxErr,"meanVtxSPDxErr/F"); // error mean of SPD vertex position - x
ttree->Branch("meanVtxSPDyErr",&meanVtxSPDyErr,"meanVtxSPDyErr/F"); // error mean of SPD vertex position - y
ttree->Branch("meanVtxSPDzErr",&meanVtxSPDzErr,"meanVtxSPDzErr/F"); // error mean of SPD vertex position - z
ttree->Branch("sigmaVtxTRKx",&sigmaVtxTRKx,"sigmaVtxTRKx/F"); // sigma of tracks vertex position - x
ttree->Branch("sigmaVtxTRKy",&sigmaVtxTRKy,"sigmaVtxTRKy/F"); // sigma of tracks vertex position - y
ttree->Branch("sigmaVtxTRKz",&sigmaVtxTRKz,"sigmaVtxTRKz/F"); // sigma of tracks vertex position - z
ttree->Branch("sigmaVtxTRKxErr",&sigmaVtxTRKxErr,"sigmaVtxTRKxErr/F"); // error sigma of tracks vertex position - x
ttree->Branch("sigmaVtxTRKyErr",&sigmaVtxTRKyErr,"sigmaVtxTRKyErr/F"); // error sigma of tracks vertex position - y
ttree->Branch("sigmaVtxTRKzErr",&sigmaVtxTRKzErr,"sigmaVtxTRKzErr/F"); // error sigma of tracks vertex position - z
ttree->Branch("sigmaVtxSPDx",&sigmaVtxSPDx,"sigmaVtxSPDx/F"); // sigma of tracks vertex position - x
ttree->Branch("sigmaVtxSPDy",&sigmaVtxSPDy,"sigmaVtxSPDy/F"); // sigma of tracks vertex position - y
ttree->Branch("sigmaVtxSPDz",&sigmaVtxSPDz,"sigmaVtxSPDz/F"); // sigma of tracks vertex position - z
ttree->Branch("sigmaVtxSPDxErr",&sigmaVtxSPDxErr,"sigmaVtxSPDxErr/F"); // error sigma of tracks vertex position - x
ttree->Branch("sigmaVtxSPDyErr",&sigmaVtxSPDyErr,"sigmaVtxSPDyErr/F"); // error sigma of tracks vertex position - y
ttree->Branch("sigmaVtxSPDzErr",&sigmaVtxSPDzErr,"sigmaVtxSPDzErr/F"); // error sigma of tracks vertex position - z
ttree->Branch("MPVL5",&MPVL5,"MPVL5/F"); // Most Probable Value dEdx Layer 5
ttree->Branch("MPVErrL5",&MPVErrL5,"MPVErrL5/F"); // Most Probable Value error dEdx Layer 5
ttree->Branch("MPVL6",&MPVL6,"MPVL6/F"); // Most Probable Value dEdx Layer 6
ttree->Branch("MPVErrL6",&MPVErrL6,"MPVErrL6/F"); // Most Probable Value error dEdx Layer 6
ttree->Branch("ChargeRatioL5",&ChargeRatioL5,"ChargeRatioL5/F"); // Charge ratio (2 sides of SSD) Layer 5
ttree->Branch("ChargeRatioErrL5",&ChargeRatioErrL5,"ChargeRatioErrL5/F"); // Charge ratio error (2 sides of SSD) Layer 5
ttree->Branch("ChargeRatioL6",&ChargeRatioL6,"ChargeRatioL6/F"); // Charge ratio (2 sides of SSD) Layer 6
ttree->Branch("ChargeRatioErrL6",&ChargeRatioErrL6,"ChargeRatioErrL6/F"); // Charge ratio error(2 sides of SSD) Layer 6
ttree->Branch("EmptyModulesSDD",&EmptyModulesSDD,"EmptyModulesSDD/F"); // Number of empty SSD modules
ttree->Branch("fracExtra",&fracExtra,"fracExtra/F"); // fraction of extra clusters in SDD
ttree->Branch("errfracExtra",&errfracExtra,"errfracExtra/F"); // fraction of extra clusters in SDD
ttree->Branch("minTime",&minTime,"minTime/F"); // minimum drift time SDD
ttree->Branch("errMinTime",&errMinTime,"errMinTime/F"); // error on minimum drift time SDD
ttree->Branch("MPVdEdxLay3",&MPVdEdxLay3,"MPVdEdxLay3/F"); // most probable value of dE/Fx distribution of SDD Layer 3
ttree->Branch("errMPVdEdxLay3",&errMPVdEdxLay3,"errMPVdEdxLay3/F"); // error most probable value of dE/Fx distribution of SDD Layer 3
ttree->Branch("MPVdEdxLay4",&MPVdEdxLay4,"MPVdEdxLay4/F"); // most probable value of dE/Fx distribution of SDD Layer 4
ttree->Branch("errMPVdEdxLay4",&errMPVdEdxLay4,"errMPVdEdxLay4/F"); // error most probable value of dE/Fx distribution of SDD Layer 4
ttree->Branch("MPVdEdxTB0",&MPVdEdxTB0,"MPVdEdxTB0/F"); // most probable value of dE/Fx distribution of SDD - small drift time
ttree->Branch("errMPVdEdxTB0",&errMPVdEdxTB0,"errMPVdEdxTB0/F"); // most probable value of dE/Fx distribution of SDD - small drift time
ttree->Branch("MPVdEdxTB5",&MPVdEdxTB5,"MPVdEdxTB5/F"); // most probable value of dE/Fx distribution of SDD - large drift time
ttree->Branch("errMPVdEdxTB5",&errMPVdEdxTB5,"errMPVdEdxTB5/F"); // most probable value of dE/Fx distribution of SDD - large drift time
ttree->Branch("Eff6Pt02",&Eff6Pt02,"Eff6Pt02/F"); // matching efficiency low pt 6 clusters
ttree->Branch("errEff6Pt02",&errEff6Pt02,"errEff6Pt02/F"); // error matching efficiency low pt 6 clusters
ttree->Branch("Eff5Pt02",&Eff5Pt02,"Eff5Pt02/F"); // matching efficiency low pt 5 clusters
ttree->Branch("errEff5Pt02",&errEff5Pt02,"errEff5Pt02/F"); // error matching efficiency low pt 5 clusters
ttree->Branch("Eff4Pt02",&Eff4Pt02,"Eff4Pt02/F"); // matching efficiency low pt 4 clusters
ttree->Branch("errEff4Pt02",&errEff4Pt02,"errEff4Pt02/F"); // error matching efficiency low pt 4 clusters
ttree->Branch("Eff3Pt02",&Eff3Pt02,"Eff3Pt02/F"); // matching efficiency low pt 3 clusters
ttree->Branch("errEff3Pt02",&errEff3Pt02,"errEff3Pt02/F"); // error matching efficiency low pt 3 clusters
ttree->Branch("Eff2Pt02",&Eff2Pt02,"Eff2Pt02/F"); // matching efficiency low pt 2 clusters
ttree->Branch("errEff2Pt02",&errEff2Pt02,"errEff2Pt02/F"); // error matching efficiency low pt 2 clusters
ttree->Branch("EffSPDPt02",&EffSPDPt02,"EffSPDPt02/F"); // matching efficiency low pt 2 SPD
ttree->Branch("errEffSPDPt02",&errEffSPDPt02,"errEffSPDPt02/F"); // error matching efficiency low pt 2 SPD
ttree->Branch("EffoneSPDPt02",&EffoneSPDPt02,"EffoneSPDPt02/F"); // matching efficiency low pt 6 one SPD
ttree->Branch("errEffoneSPDPt02",&errEffoneSPDPt02,"errEffoneSPDPt02/F"); // error matching efficiency low pt one SPD
ttree->Branch("EffTOTPt02",&EffTOTPt02,"EffTOTPt02/F"); // matching efficiency low pt
ttree->Branch("errEffTOTPt02",&errEffTOTPt02,"errEffTOTPt02/F"); // error matching efficiency low pt
ttree->Branch("Eff6Pt1",&Eff6Pt1,"Eff6Pt1/F"); // matching efficiency mid pt 6 clusters
ttree->Branch("errEff6Pt1",&errEff6Pt1,"errEff6Pt1/F"); // error matching efficiency mid pt 6 clusters
ttree->Branch("Eff5Pt1",&Eff5Pt1,"Eff5Pt1/F"); // matching efficiency mid pt 5 clusters
ttree->Branch("errEff5Pt1",&errEff5Pt1,"errEff5Pt1/F"); // error matching efficiency mid pt 5 clusters
ttree->Branch("Eff4Pt1",&Eff4Pt1,"Eff4Pt1/F"); // matching efficiency mid pt 4 clusters
ttree->Branch("errEff4Pt1",&errEff4Pt1,"errEff4Pt1/F"); // error matching efficiency mid pt 4 clusters
ttree->Branch("Eff3Pt1",&Eff3Pt1,"Eff3Pt1/F"); // matching efficiency mid pt 3 clusters
ttree->Branch("errEff3Pt1",&errEff3Pt1,"errEff3Pt1/F"); // error matching efficiency mid pt 3 clusters
ttree->Branch("Eff2Pt1",&Eff2Pt1,"Eff2Pt1/F"); // matching efficiency mid pt 2 clusters
ttree->Branch("errEff2Pt1",&errEff2Pt1,"errEff2Pt1/F"); // error matching efficiency mid pt 2 clusters
ttree->Branch("EffSPDPt1",&EffSPDPt1,"EffSPDPt1/F"); // matching efficiency mid pt 2 SPD
ttree->Branch("errEffSPDPt1",&errEffSPDPt1,"errEffSPDPt1/F"); // error matching efficiency mid pt 2 SPD
ttree->Branch("EffoneSPDPt1",&EffoneSPDPt1,"EffoneSPDPt1/F"); // matching efficiency mid pt 6 one SPD
ttree->Branch("errEffoneSPDPt1",&errEffoneSPDPt1,"errEffoneSPDPt1/F"); // error matching efficiency mid pt one SPD
ttree->Branch("EffTOTPt1",&EffTOTPt1,"EffTOTPt1/F"); // matching efficiency mid pt
ttree->Branch("errEffTOTPt1",&errEffTOTPt1,"errEffTOTPt1/F"); // error matching efficiency mid pt
ttree->Branch("Eff6Pt10",&Eff6Pt10,"Eff6Pt10/F"); // matching efficiency high pt 6 clusters
ttree->Branch("errEff6Pt10",&errEff6Pt10,"errEff6Pt10/F"); // error matching efficiency high pt 6 clusters
ttree->Branch("Eff5Pt10",&Eff5Pt10,"Eff5Pt10/F"); // matching efficiency high pt 5 clusters
ttree->Branch("errEff5Pt10",&errEff5Pt10,"errEff5Pt10/F"); // error matching efficiency high pt 5 clusters
ttree->Branch("Eff4Pt10",&Eff4Pt10,"Eff4Pt10/F"); // matching efficiency high pt 4 clusters
ttree->Branch("errEff4Pt10",&errEff4Pt10,"errEff4Pt10/F"); // error matching efficiency high pt 4 clusters
ttree->Branch("Eff3Pt10",&Eff3Pt10,"Eff3Pt10/F"); // matching efficiency high pt 3 clusters
ttree->Branch("errEff3Pt10",&errEff3Pt10,"errEff3Pt10/F"); // error matching efficiency high pt 3 clusters
ttree->Branch("Eff2Pt10",&Eff2Pt10,"Eff2Pt10/F"); // matching efficiency high pt 2 clusters
ttree->Branch("errEff2Pt10",&errEff2Pt10,"errEff2Pt10/F"); // error matching efficiency high pt 2 clusters
ttree->Branch("EffSPDPt10",&EffSPDPt10,"EffSPDPt10/F"); // matching efficiency high pt 2 SPD
ttree->Branch("errEffSPDPt10",&errEffSPDPt10,"errEffSPDPt10/F"); // error matching efficiency high pt 2 SPD
ttree->Branch("EffoneSPDPt10",&EffoneSPDPt10,"EffoneSPDPt10/F"); // matching efficiency high pt 6 one SPD
ttree->Branch("errEffoneSPDPt10",&errEffoneSPDPt10,"errEffoneSPDPt10/F"); // error matching efficiency high pt one SPD
ttree->Branch("EffTOTPt10",&EffTOTPt10,"EffTOTPt10/F"); // matching efficiency high pt
ttree->Branch("errEffTOTPt10",&errEffTOTPt10,"errEffTOTPt10/F"); // error matching efficiency high pt
ttree->Branch("FracSPD1",&FracSPD1,"FracSPD1/F"); // fraction SPD layers active on 1 layer
ttree->Branch("errFracSPD1",&errFracSPD1,"errFracSPD1/F");
ttree->Branch("FracSPD2",&FracSPD2,"FracSPD2/F"); // fraction SPD layers active on 1 layer
ttree->Branch("errFracSPD2",&errFracSPD2,"errFracSPD2/F");
/////////////// Vertex part
nrun=runNumber;
char VertexDirName[25]="Vertex_Performance";
char VertexListName[25]="cOutputVtxESD";
TDirectoryFile * VertexQAdir=(TDirectoryFile*)fin->Get(VertexDirName);
if (!VertexQAdir) {
Printf("ERROR: Vertex QA directory not present in input file.\n");
return -1;
}
TList * VertxList=(TList*)VertexQAdir->Get(VertexListName);
if (!VertxList) Printf("WARNING: Vertex QA histograms absent or not accessible\n");
Printf("Vertex - QA");
Int_t iRun=runNumber;
TH1F *xVtxTRK = (TH1F*)VertxList->FindObject("fhTRKVertexX");
TH1F *yVtxTRK = (TH1F*)VertxList->FindObject("fhTRKVertexY");
TH1F *zVtxTRK = (TH1F*)VertxList->FindObject("fhTRKVertexZ");
TH1F *xVtxSPD = (TH1F*)VertxList->FindObject("fhSPDVertexX");
if(xVtxSPD->GetEntries()==0){
printf("Run %d xVtxSOD EMPTY -> Return\n",iRun);
}
TH1F *yVtxSPD = (TH1F*)VertxList->FindObject("fhSPDVertexY");
if(yVtxSPD->GetEntries()==0){
printf("Run %d yVtxSPD EMPTY -> Return\n",iRun);
}
TH1F *zVtxSPD = (TH1F*)VertxList->FindObject("fhSPDVertexZ");
if(zVtxSPD->GetEntries()==0){
printf("Run %d zVtxSPD EMPTY -> Return\n",iRun);
}
TF1 *fxTRK = new TF1("gausx", "gaus", -1, 1);
xVtxTRK->Fit("gausx", "NQRL");
TF1 *fyTRK = new TF1("gausy", "gaus", -1, 1);
yVtxTRK->Fit("gausy","NQLR");
TF1 *fzTRK = new TF1("gausz", "gaus", -1, 1);
zVtxTRK->Fit("gausz","NQRL");
TF1 *fxSPD = new TF1("gausxSPD", "gaus", -1, 1);
xVtxSPD->Fit("gausxSPD", "NQRL");
TF1 *fySPD = new TF1("gausySPD", "gaus", -1, 1);
yVtxSPD->Fit("gausySPD","NQLR");
TF1 *fzSPD = new TF1("gauszSPD", "gaus", -1, 1);
zVtxSPD->Fit("gauszSPD","NQRL");
meanVtxTRKx=(Float_t)fxTRK->GetParameter(1);
meanVtxTRKxErr=(Float_t)fxTRK->GetParError(1);
sigmaVtxTRKx=(Float_t)fxTRK->GetParameter(2);
sigmaVtxTRKxErr=(Float_t)fxTRK->GetParError(2);
meanVtxTRKy=(Float_t)fyTRK->GetParameter(1);
meanVtxTRKyErr=(Float_t)fyTRK->GetParError(1);
sigmaVtxTRKy=(Float_t)fyTRK->GetParameter(2);
sigmaVtxTRKyErr=(Float_t)fyTRK->GetParError(2);
meanVtxTRKz=(Float_t)fzTRK->GetParameter(1);
meanVtxTRKzErr=(Float_t)fzTRK->GetParError(1);
sigmaVtxTRKz=(Float_t)fzTRK->GetParameter(2);
sigmaVtxTRKzErr=(Float_t)fzTRK->GetParError(2);
meanVtxSPDx=(Float_t)fxSPD->GetParameter(1);
meanVtxSPDxErr=(Float_t)fxSPD->GetParError(1);
sigmaVtxSPDx=(Float_t)fxSPD->GetParameter(2);
sigmaVtxSPDxErr=(Float_t)fxSPD->GetParError(2);
meanVtxSPDy=(Float_t)fySPD->GetParameter(1);
meanVtxSPDyErr=(Float_t)fySPD->GetParError(1);
sigmaVtxSPDy=(Float_t)fySPD->GetParameter(2);
sigmaVtxSPDyErr=(Float_t)fySPD->GetParError(2);
meanVtxSPDz=(Float_t)fzSPD->GetParameter(1);
sigmaVtxSPDzErr=(Float_t)fzSPD->GetParError(1);
sigmaVtxSPDz=(Float_t)fzSPD->GetParameter(2);
sigmaVtxSPDzErr=(Float_t)fzSPD->GetParError(2);
/////////// end of vertex part
/////////////////////// SSD Part
char SSDDirName[25]="PWGPPdEdxSSDQA";
char SSDListName[25]="SSDdEdxQA";
TDirectoryFile * SSDQAdir=(TDirectoryFile*)fin->Get(SSDDirName);
if (!SSDQAdir) {
Printf("ERROR: SSD QA directory not present in input file.\n");
return -1;
}
TList * SSDList=(TList*)SSDQAdir->Get(SSDListName);
if (!SSDList) Printf("WARNING: SSD QA histograms absent or not accessible\n");
Printf("SSD - QA");
MPVL5=0;
MPVErrL5=0;
MPVL6=0;
MPVErrL6=0;
ChargeRatioL5=0;
ChargeRatioErrL5=0;
ChargeRatioL6=0;
ChargeRatioErrL6=0;
EmptyModulesSDD=0;
TH2F* QAchargeRatio=(TH2F*)SSDList->FindObject("QAChargeRatio");
if(QAchargeRatio->GetEntries()==0){
printf("Run %d QAchargeRatio EMPTY -> Return\n",iRun);
}
TH2F* QAcharge=(TH2F*)SSDList->FindObject("QACharge");
if(QAcharge->GetEntries()==0){
printf("Run %d QAcharge EMPTY -> Return\n",iRun);
}
if((QAcharge)&&(QAchargeRatio)&&(QAcharge->GetEntries()>10)&&(QAchargeRatio->GetEntries()>10)){
Int_t biny = QAcharge->GetXaxis()->FindBin(747);
Int_t maxy = QAcharge->GetXaxis()->GetXmax();
Int_t contEmpty=0;
Int_t contFull=0;
TH1D *hChargeL5=QAcharge->ProjectionY("hChargeL5",0,biny);
TH1D *hChargeL6=QAcharge->ProjectionY("hChargeL6",biny,maxy);
TH1D *hChargeRatioL5=QAchargeRatio->ProjectionY("hChargeRatioL5",0,biny);
TH1D *hChargeRatioL6=QAchargeRatio->ProjectionY("hChargeRatioL6",biny,maxy);
if(QAcharge->GetEntries()< 45000)
contEmpty=1;
else{
for(Int_t i =0;i<1698;i++){
TString tmpQ("Q");
tmpQ+=i;
TH1D* fHist1DQ= QAcharge->ProjectionY(tmpQ,i+1,i+1);
Double_t mean=fHist1DQ->GetMean();
if(TMath::Abs(mean)<1.0 ||fHist1DQ->GetEntries()<10)
contEmpty++;
else
contFull++;
}
}
TF1 *lfunLay5 = new TF1("LangausFunLay5",LangausFun,50.,300.,4);
lfunLay5->SetParameter(0,5.);
lfunLay5->SetParameter(1,80.);
lfunLay5->SetParameter(2,hChargeL5->GetEntries()/10.);
lfunLay5->SetParameter(3,10.);
lfunLay5->SetParLimits(3,0.,20);
hChargeL5->Fit(lfunLay5,"NQLR");
TF1 *lfunLay6 = new TF1("LangausFunLay6",LangausFun,50.,300.,4);
lfunLay6->SetParameter(0,5.);
lfunLay6->SetParameter(1,80.);
lfunLay6->SetParameter(2,hChargeL6->GetEntries()/10.);
lfunLay6->SetParameter(3,10.);
lfunLay6->SetParLimits(3,0.,20);
hChargeL6->Fit(lfunLay6,"NQLR");
MPVL5=(Float_t)lfunLay5->GetParameter(1);
MPVErrL5=(Float_t)lfunLay5->GetParError(1);
MPVL6=(Float_t)lfunLay6->GetParameter(1);
MPVErrL6=(Float_t)lfunLay6->GetParError(1);
ChargeRatioL5=(Float_t)hChargeRatioL5->GetMean();
ChargeRatioErrL5=(Float_t)hChargeRatioL5->GetMeanError();
ChargeRatioL6=(Float_t)hChargeRatioL6->GetMean();
ChargeRatioErrL6=(Float_t)hChargeRatioL6->GetMeanError();
EmptyModulesSDD=(Float_t)contEmpty;
}
/////////// end of SSD part
/////////////////////// SDD Part
char SDDDirName[25]="SDD_Performance";
char SDDListName[15]="coutputRP";
TDirectoryFile * SDDQAdir=(TDirectoryFile*)fin->Get(SDDDirName);
if (!SDDQAdir) {
Printf("ERROR: SDD QA directory not present in input file.\n");
return -1;
}
TList * SDDList=(TList*)SDDQAdir->Get(SDDListName);
if (!SDDList) Printf("WARNING: SDD QA histograms absent or not accessible\n");
Printf("SDD - QA");
TH1F* hcllay=(TH1F*)SDDList->FindObject("hCluInLay");
if(hcllay->GetBinContent(1)>0){
for(Int_t iLay=0; iLay<6; iLay++){
fracT[iLay]=hcllay->GetBinContent(iLay+2)/hcllay->GetBinContent(1);
efracT[iLay]=TMath::Sqrt(fracT[iLay]*(1-fracT[iLay])/hcllay->GetBinContent(1));
}
}
fracTrackWithClu1=fracT[0];
errfracTrackWithClu1=efracT[0];
fracTrackWithClu2=fracT[1];
errfracTrackWithClu2=efracT[1];
fracTrackWithClu3=fracT[2];
errfracTrackWithClu3=efracT[2];
fracTrackWithClu4=fracT[3];
errfracTrackWithClu4=efracT[3];
fracTrackWithClu5=fracT[4];
errfracTrackWithClu5=efracT[4];
fracTrackWithClu6=fracT[5];
errfracTrackWithClu6=efracT[5];
cout<<endl<<errfracTrackWithClu6<<endl;
TH1F* hmodT=(TH1F*)SDDList->FindObject("hTPMod");
TH1F* hgamod=(TH1F*)SDDList->FindObject("hGAMod");
TH1F* hev=(TH1F*)SDDList->FindObject("hNEvents");
nTotEvents=hev->GetBinContent(2);
nTrigEvents=hev->GetBinContent(3);
nEvents=nTotEvents;
TH1F* htimT=(TH1F*)SDDList->FindObject("hDrTimTPAll");
TH1F* htimTe=(TH1F*)SDDList->FindObject("hDrTimTPExtra");
if(htimT->GetEntries()>0){
fracExtra=htimTe->GetEntries()/htimT->GetEntries();
errfracExtra=TMath::Sqrt(htimTe->GetEntries())/htimT->GetEntries();
}
for(Int_t iBin=1; iBin<=htimT->GetNbinsX(); iBin++){
Float_t tim=htimT->GetBinCenter(iBin);
if(tim>2000. && tim<4000.){
averPoints+=htimT->GetBinContent(iBin);
cntBins+=1;
}
}
if(cntBins>0){
averPoints/=cntBins;
for(Int_t iBin=1; iBin<=htimT->GetNbinsX(); iBin++){
if(htimT->GetBinContent(iBin)>0.5*averPoints){
minDrTime=htimT->GetBinCenter(iBin);
errminDrTime=0.5*htimT->GetBinWidth(iBin);
break;
}
}
}
meanDrTime=htimT->GetMean();
errmeanDrTime=htimT->GetMeanError();
TH2F* hdedxmod=(TH2F*)SDDList->FindObject("hdEdxVsMod");
TH1D* hdedxLay3=hdedxmod->ProjectionY("hdedxLay3",1,84);
TH1D* hdedxLay4=hdedxmod->ProjectionY("hdedxLay4",85,260);
TH1F* hSigTim0=(TH1F*)SDDList->FindObject("hSigTimeInt0");
TH1F* hSigTim5=(TH1F*)SDDList->FindObject("hSigTimeInt5");
//Fitting the same distributions in order to have the MPV
TF1 *lfunLay3 = new TF1("LangausFunLay3",LangausFun,50.,300.,4);
lfunLay3->SetParameter(0,5.);
lfunLay3->SetParameter(1,80.);
lfunLay3->SetParameter(2,hdedxLay3->GetEntries()/10.);
lfunLay3->SetParameter(3,10.);
lfunLay3->SetParLimits(3,0.,20);
hdedxLay3->Fit(lfunLay3,"NQLR");
TF1 *lfunLay4 = new TF1("LangausFunLay4",LangausFun,50.,300.,4);
lfunLay4->SetParameter(0,5.);
lfunLay4->SetParameter(1,80.);
lfunLay4->SetParameter(2,hdedxLay4->GetEntries()/10.);
lfunLay4->SetParameter(3,10.);
lfunLay4->SetParLimits(3,0.,20);
hdedxLay4->Fit(lfunLay4,"NQLR");
TF1 *lfunTim0 = new TF1("LangausFunTim0",LangausFun,50.,300.,4);
lfunTim0->SetParameter(0,5.);
lfunTim0->SetParameter(1,80.);
lfunTim0->SetParameter(2,hSigTim0->GetEntries()/10.);
lfunTim0->SetParameter(3,10.);
lfunTim0->SetParLimits(3,0.,20);
hSigTim0->Fit(lfunTim0,"NQLR");
TF1 *lfunTim5 = new TF1("LangausFunTim5",LangausFun,50.,300.,4);
lfunTim5->SetParameter(0,5.);
lfunTim5->SetParameter(1,80.);
lfunTim5->SetParameter(2,hSigTim5->GetEntries()/10.);
lfunTim5->SetParameter(3,10.);
lfunTim5->SetParLimits(3,0.,20);
hSigTim5->Fit(lfunTim5,"NQLR");
MPVdEdxLay3=lfunLay3->GetParameter(1);
errMPVdEdxLay3=lfunLay3->GetParError(1);
MPVdEdxLay4=lfunLay4->GetParameter(1);
errMPVdEdxLay4=lfunLay4->GetParError(1);
MPVdEdxTB0=lfunTim0->GetParameter(1);
errMPVdEdxTB0=lfunTim0->GetParError(1);
MPVdEdxTB5=lfunTim5->GetParameter(1);
errMPVdEdxTB5=lfunTim5->GetParError(1);
/////////// end of SDD part
// Matching Part
cout<<"Tracking"<<endl;
TDirectoryFile *dirMatch=(TDirectoryFile*)fin->GetDirectory("ITS_Performance");
TList *list=NULL;
TList *listSPD=NULL;
if(dirMatch) {
list = (TList*)dirMatch->Get("cOutputITS"); // LHC12e
}
dirMatch=(TDirectoryFile*)fin->GetDirectory("SPD_Performance");
if(dirMatch) listSPD = (TList*)dirMatch->Get("coutput1");
// if(!list) return kFALSE;
Float_t ioValues[30];
Float_t ioErrors[30];
for(Int_t jj=0;jj<30;jj++){
ioValues[jj]=0.;
ioErrors[jj]=0.;
}
Float_t ptbin=0;
TH1F *hFiredChip = (TH1F*)listSPD->FindObject("hFiredChip");
if(hFiredChip->GetEntries()==0){
printf("Run %d hFiredChip EMPTY -> Return\n",iRun);
}
Int_t nHSsInner=0,nHSsOuter=0;
for(Int_t i=0;i<400;i++) if(hFiredChip->GetBinContent(i)>0) nHSsInner++;
for(Int_t i=400;i<1200;i++) if(hFiredChip->GetBinContent(i)>0) nHSsOuter++;
nHSsInner = (Int_t)(nHSsInner/10);
nHSsOuter = (Int_t)(nHSsOuter/10);
ioValues[0]=(Float_t)nHSsInner/40.;
ioValues[1]=(Float_t)nHSsOuter/80.;
TH1F *fHistPtTPCInAcc = (TH1F*)list->FindObject("fHistPtTPCInAcc");
Int_t check1=0;
if(fHistPtTPCInAcc->GetEntries()==0){
check1=1;
printf("Run %dfHistPtTPCInAcc EMPTY -> Return\n",iRun);
}
TH1F *fHistPtITSMI6InAcc = (TH1F*)list->FindObject("fHistPtITSMI6InAcc");
TH1F *fHistPtITSMI5InAcc = (TH1F*)list->FindObject("fHistPtITSMI5InAcc");
TH1F *fHistPtITSMI4InAcc = (TH1F*)list->FindObject("fHistPtITSMI4InAcc");
TH1F *fHistPtITSMI3InAcc = (TH1F*)list->FindObject("fHistPtITSMI3InAcc");
TH1F *fHistPtITSMI2InAcc = (TH1F*)list->FindObject("fHistPtITSMI2InAcc");
TH1F *fHistPtITSMISPDInAcc = (TH1F*)list->FindObject("fHistPtITSMISPDInAcc");
TH1F *fHistPtITSMIoneSPDInAcc = (TH1F*)list->FindObject("fHistPtITSMIoneSPDInAcc");
TH1F *fHistPtITSMIge2InAcc = (TH1F*)fHistPtITSMI6InAcc->Clone("fHistPtITSMIge2InAcc");
fHistPtITSMIge2InAcc->Add(fHistPtITSMI5InAcc);
fHistPtITSMIge2InAcc->Add(fHistPtITSMI4InAcc);
fHistPtITSMIge2InAcc->Add(fHistPtITSMI3InAcc);
fHistPtITSMIge2InAcc->Add(fHistPtITSMI2InAcc);
fHistPtITSMI6InAcc->Divide(fHistPtITSMI6InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMI6InAcc->FindBin(0.201);
ioValues[2]=fHistPtITSMI6InAcc->GetBinContent(ptbin);
ioErrors[2]=fHistPtITSMI6InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI6InAcc->FindBin(1.001);
ioValues[3]=fHistPtITSMI6InAcc->GetBinContent(ptbin);
ioErrors[3]=fHistPtITSMI6InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI6InAcc->FindBin(10.001);
ioValues[4]=fHistPtITSMI6InAcc->GetBinContent(ptbin);
ioErrors[4]=fHistPtITSMI6InAcc->GetBinError(ptbin);
fHistPtITSMI5InAcc->Divide(fHistPtITSMI5InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMI5InAcc->FindBin(0.201);
ioValues[5]=fHistPtITSMI5InAcc->GetBinContent(ptbin);
ioErrors[5]=fHistPtITSMI5InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI5InAcc->FindBin(1.001);
ioValues[6]=fHistPtITSMI5InAcc->GetBinContent(ptbin);
ioErrors[6]=fHistPtITSMI5InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI5InAcc->FindBin(10.001);
ioValues[7]=fHistPtITSMI5InAcc->GetBinContent(ptbin);
ioErrors[7]=fHistPtITSMI5InAcc->GetBinError(ptbin);
fHistPtITSMI4InAcc->Divide(fHistPtITSMI4InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMI4InAcc->FindBin(0.201);
ioValues[9]=fHistPtITSMI4InAcc->GetBinContent(ptbin);
ioErrors[9]=fHistPtITSMI4InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI4InAcc->FindBin(1.001);
ioValues[10]=fHistPtITSMI4InAcc->GetBinContent(ptbin);
ioErrors[10]=fHistPtITSMI4InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI4InAcc->FindBin(10.001);
ioValues[11]=fHistPtITSMI4InAcc->GetBinContent(ptbin);
ioErrors[11]=fHistPtITSMI4InAcc->GetBinError(ptbin);
fHistPtITSMI3InAcc->Divide(fHistPtITSMI3InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMI3InAcc->FindBin(0.201);
ioValues[12]=fHistPtITSMI3InAcc->GetBinContent(ptbin);
ioErrors[12]=fHistPtITSMI3InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI3InAcc->FindBin(1.001);
ioValues[13]=fHistPtITSMI3InAcc->GetBinContent(ptbin);
ioErrors[13]=fHistPtITSMI3InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI3InAcc->FindBin(10.001);
ioValues[14]=fHistPtITSMI3InAcc->GetBinContent(ptbin);
ioErrors[14]=fHistPtITSMI3InAcc->GetBinError(ptbin);
fHistPtITSMI2InAcc->Divide(fHistPtITSMI2InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMI2InAcc->FindBin(0.201);
ioValues[15]=fHistPtITSMI2InAcc->GetBinContent(ptbin);
ioErrors[15]=fHistPtITSMI2InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI2InAcc->FindBin(1.001);
ioValues[16]=fHistPtITSMI2InAcc->GetBinContent(ptbin);
ioErrors[16]=fHistPtITSMI2InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMI2InAcc->FindBin(10.001);
ioValues[17]=fHistPtITSMI2InAcc->GetBinContent(ptbin);
ioErrors[17]=fHistPtITSMI2InAcc->GetBinError(ptbin);
fHistPtITSMISPDInAcc->Divide(fHistPtITSMISPDInAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMISPDInAcc->FindBin(0.201);
ioValues[18]=fHistPtITSMISPDInAcc->GetBinContent(ptbin);
ioErrors[18]=fHistPtITSMISPDInAcc->GetBinError(ptbin);
ptbin=fHistPtITSMISPDInAcc->FindBin(1.001);
ioValues[19]=fHistPtITSMISPDInAcc->GetBinContent(ptbin);
ioErrors[19]=fHistPtITSMISPDInAcc->GetBinError(ptbin);
ptbin=fHistPtITSMISPDInAcc->FindBin(10.001);
ioValues[20]=fHistPtITSMISPDInAcc->GetBinContent(ptbin);
ioErrors[20]=fHistPtITSMISPDInAcc->GetBinError(ptbin);
fHistPtITSMIoneSPDInAcc->Divide(fHistPtITSMIoneSPDInAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMIoneSPDInAcc->FindBin(0.201);
ioValues[21]=fHistPtITSMIoneSPDInAcc->GetBinContent(ptbin);
ioErrors[21]=fHistPtITSMIoneSPDInAcc->GetBinError(ptbin);
ptbin=fHistPtITSMIoneSPDInAcc->FindBin(1.001);
ioValues[22]=fHistPtITSMIoneSPDInAcc->GetBinContent(ptbin);
ioErrors[22]=fHistPtITSMIoneSPDInAcc->GetBinError(ptbin);
ptbin=fHistPtITSMIoneSPDInAcc->FindBin(10.001);
ioValues[23]=fHistPtITSMIoneSPDInAcc->GetBinContent(ptbin);
ioErrors[23]=fHistPtITSMIoneSPDInAcc->GetBinError(ptbin);
fHistPtITSMIge2InAcc->Divide(fHistPtITSMIge2InAcc,fHistPtTPCInAcc,1,1,"B");
ptbin=fHistPtITSMIge2InAcc->FindBin(0.201);
ioValues[24]=fHistPtITSMIge2InAcc->GetBinContent(ptbin);
ioErrors[24]=fHistPtITSMIge2InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMIge2InAcc->FindBin(1.001);
ioValues[25]=fHistPtITSMIge2InAcc->GetBinContent(ptbin);
ioErrors[25]=fHistPtITSMIge2InAcc->GetBinError(ptbin);
ptbin=fHistPtITSMIge2InAcc->FindBin(10.001);
ioValues[26]=fHistPtITSMIge2InAcc->GetBinContent(ptbin);
ioErrors[26]=fHistPtITSMIge2InAcc->GetBinError(ptbin);
FracSPD1=ioValues[0];
errFracSPD1=ioErrors[0];
FracSPD2=ioValues[1];
errFracSPD2=ioErrors[1];
Eff6Pt02=ioValues[2];
errEff6Pt02=ioErrors[2];
Eff6Pt1=ioValues[3];
errEff6Pt1=ioErrors[3];
Eff6Pt10=ioValues[4];
errEff6Pt10=ioErrors[4];
Eff5Pt02=ioValues[5];
errEff5Pt02=ioErrors[5];
Eff5Pt1=ioValues[6];
errEff5Pt1=ioErrors[6];
Eff5Pt10=ioValues[7];
errEff5Pt10=ioErrors[7];
Eff4Pt02=ioValues[8];
errEff4Pt02=ioErrors[8];
Eff4Pt1=ioValues[9];
errEff4Pt1=ioErrors[9];
Eff4Pt10=ioValues[10];
errEff4Pt10=ioErrors[10];
Eff3Pt02=ioValues[11];
errEff3Pt02=ioErrors[11];
Eff3Pt1=ioValues[12];
errEff3Pt1=ioErrors[12];
Eff3Pt10=ioValues[13];
errEff3Pt10=ioErrors[13];
Eff2Pt02=ioValues[14];
errEff2Pt02=ioErrors[14];
Eff2Pt1=ioValues[15];
errEff2Pt1=ioErrors[15];
Eff2Pt10=ioValues[16];
errEff2Pt10=ioErrors[16];
EffSPDPt02=ioValues[17];
errEffSPDPt02=ioErrors[17];
EffSPDPt1=ioValues[18];
errEffSPDPt1=ioErrors[18];
EffSPDPt10=ioValues[19];
errEffSPDPt10=ioErrors[19];
EffoneSPDPt02=ioValues[20];
errEffoneSPDPt02=ioErrors[20];
EffoneSPDPt1=ioValues[21];
errEffoneSPDPt1=ioErrors[21];
EffoneSPDPt10=ioValues[22];
errEffoneSPDPt10=ioErrors[22];
EffTOTPt02=ioValues[23];
errEffTOTPt02=ioErrors[23];
EffTOTPt1=ioValues[24];
errEffTOTPt1=ioErrors[24];
EffTOTPt10=ioValues[25];
errEffTOTPt10=ioErrors[25];
ttree->Fill();
printf("============== Saving trending quantities in tree for run %i ===============\n",runNumber);
trendFile->cd();
ttree->Write();
trendFile->Close();
return 1;
}
void SimEntity::setInitialPose(bool reset) {
bool worldAnchor = false;
if(!control) return;
if(config.find("rootNode") != config.end()) {
if(config.find("anchor") != config.end()) {
if((std::string)config["anchor"] == "world") {
worldAnchor = true;
}
}
NodeId id = getNode((std::string)config["rootNode"]);
NodeData myNode = control->nodes->getFullNode(id);
utils::Quaternion tmpQ(1, 0, 0, 0);
utils::Vector tmpV;
if(config.find("position") != config.end()) {
myNode.pos.x() = config["position"][0];
myNode.pos.y() = config["position"][1];
myNode.pos.z() = config["position"][2];
control->nodes->editNode(&myNode, EDIT_NODE_POS | EDIT_NODE_MOVE_ALL);
}
if(config.find("rotation") != config.end()) {
// check if euler angles or quaternion is provided; rotate around z
// if only one angle is provided
switch (config["rotation"].size()) {
case 1: tmpV[0] = 0;
tmpV[1] = 0;
tmpV[2] = config["rotation"][0];
tmpQ = utils::eulerToQuaternion(tmpV);
break;
case 3: tmpV[0] = config["rotation"][0];
tmpV[1] = config["rotation"][1];
tmpV[2] = config["rotation"][2];
tmpQ = utils::eulerToQuaternion(tmpV);
break;
case 4: tmpQ.x() = (sReal)config["rotation"][1];
tmpQ.y() = (sReal)config["rotation"][2];
tmpQ.z() = (sReal)config["rotation"][3];
tmpQ.w() = (sReal)config["rotation"][0];
break;
}
myNode.rot = tmpQ;
control->nodes->editNode(&myNode, EDIT_NODE_ROT | EDIT_NODE_MOVE_ALL);
}
if(worldAnchor) {
if (reset) {
fprintf(stderr, "Resetting initial entity pose.\n");
std::map<unsigned long, std::string>::iterator it;
JointId anchorJointId = 0;
for (it=jointIds.begin(); it!=jointIds.end(); ++it) {
if (it->second == "anchor_"+name) {
anchorJointId = it->first;
break;
}
}
SimJoint* anchorjoint = control->joints->getSimJoint(anchorJointId);
if (anchorjoint != NULL) {
anchorjoint->reattachJoint();
}
else fprintf(stderr, "Could not reset anchor of entity %s.\n", name.c_str());
}
else {
JointData anchorjoint;
anchorjoint.nodeIndex1 = id;
anchorjoint.nodeIndex2 = 0;
anchorjoint.type = JOINT_TYPE_FIXED;
anchorjoint.name = "anchor_"+name;
JointId anchorJointId = control->joints->addJoint(&anchorjoint);
addJoint(anchorJointId, anchorjoint.name);
}
}
// set Joints
configmaps::ConfigVector::iterator it;
configmaps::ConfigMap::iterator joint_it;
for (it = config["poses"].begin(); it!= config["poses"].end(); ++it) {
if ((std::string)(*it)["name"] == (std::string)config["pose"]) {
for (joint_it = (*it)["joints"][0].children.begin();
joint_it!= (*it)["joints"][0].children.end(); ++joint_it) {
//fprintf(stderr, "setMotorValue: joint: %s, id: %lu, value: %f\n", ((std::string)joint_it->first).c_str(), motorIDMap[joint_it->first], (double)joint_it->second);
control->motors->setMotorValue(getMotor(joint_it->first),
joint_it->second);
}
}
}
}
}
