void mmas::mixing() {
cerr << "Mixing star A\n";
mixing(*model_a);
cerr << "Mixing star B\n";
mixing(*model_b);
cerr << "done mixing \n";
}
TH1F* mix(int run=21, int cut=1, int bin1=3, int bin2=1, int plot=1, int method=1, TH1F* mix0=0, TH1F* mix1=0){
readfile(OPT,run);
TH1F* h1= (TH1F*)mTFile->Get(Form("phi1_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h2= (TH1F*)mTFile->Get(Form("phi2_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h3= (TH1F*)mTFile->Get(Form("dphi_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h4= (TH1F*)h3->Clone(Form("mix_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h5= (TH1F*)h3->Clone(Form("dphi_corr_%1d%1d_c%d",bin1,bin2,cut));
h4->Reset();
h5->Reset();
mixing(h1,h2,h3,h4,1);
h5->Divide(h3,h4);
mix0=h4;
TH1F* h11= (TH1F*)mTFile->Get(Form("phi0_%1d_c%d",bin1,cut));
TH1F* h12= (TH1F*)mTFile->Get(Form("phi0_%1d_c%d",bin2,cut));
TH1F* h13= (TH1F*)mTFile->Get(Form("dphi_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h14= (TH1F*)h3->Clone(Form("mix2_%1d%1d_c%d",bin1,bin2,cut));
TH1F* h15= (TH1F*)h3->Clone(Form("dphi_corr2_%1d%1d_c%d",bin1,bin2,cut));
h14->Reset();
h15->Reset();
mixing(h11,h12,h13,h14,0);
h15->Divide(h13,h14);
mix1=h14;
if(plot==1){
TText* t;
gStyle->SetOptStat(0);
c1->Divide(2,2);
c1->cd(1); h1->SetMinimum(0); h1->SetLineWidth(2); h1->Draw();
h11->Scale(h1->GetEntries()/h11->GetEntries()); h11->SetLineWidth(2); h11->SetLineColor(6); h11->Draw("same");
t = new TText(0.2, 0.85,Form("%s %s",CBEAM,CCUT[cut])); t->SetNDC(); t->SetTextSize(0.06); t->SetTextColor(1); t->Draw();
c1->cd(2); h2->SetMinimum(0); h2->SetLineWidth(2); h2->Draw();
if(h11!=h12)h12->Scale(h2->GetEntries()/h12->GetEntries());
h12->SetLineWidth(2); h12->SetLineColor(6); h12->Draw("same");
float m4=h4->GetMaximum();
c1->cd(4); h4->SetMinimum(0); h4->SetLineWidth(2); h4->SetMaximum(m4*1.1); h4->Draw();
h14->SetLineWidth(2); h4->SetLineColor(6); h14->Draw("same");
c1->cd(3);
h3->Rebin(2); h5->Rebin(2); h15->Rebin(2);
float m3=h3->GetBinContent(h3->GetNbinsX()*3/4);
h3->SetMinimum(0); h3->SetLineWidth(2); h3->SetMaximum(m3*1.5); h3->SetLineColor(1); h3->Draw();
h5->SetLineWidth(2); h5->SetLineColor(2); h5->Draw("same");
h15->SetLineWidth(2); h15->SetLineColor(6); h15->Draw("same");
t= new TText(0.20, 0.25,"UnCorrected"); t->SetTextSize(0.05); t->SetTextColor(1); t->SetNDC(); t->Draw();
t= new TText(0.20, 0.20,"Corrected"); t->SetTextSize(0.05); t->SetTextColor(2); t->SetNDC(); t->Draw();
t= new TText(0.20, 0.15,"Corrected2"); t->SetTextSize(0.05); t->SetTextColor(6); t->SetNDC(); t->Draw();
c1->SaveAs(Form("plot/mix_%s_%1d%1d_c%d.png",CBEAM,bin1,bin2,cut));
}
if(method==0) return h5;
else return h15;
}
//------- THE FUNCTIONS ---------------------------------------
Double_t lftmosc_plt(Double_t *x, Double_t *par)
{
Double_t t = x[0];
Double_t t0 = par[0];
Double_t dm = par[1];
Double_t s = par[2];
Int_t tag = par[3];
Double_t func;
if (tag == -1) func = mixing(t, t0, dm, s,tag);
if (tag == 1) func = mixing(t, t0, dm, s,tag);
return func;
}
void mll_fit_pts(Int_t &npar, Double_t *gin, Double_t &f,
Double_t *par, Int_t iflag)
{
if (iflag == 1) printf("iflag %2d\n",iflag);
if (iflag == 3) printf("iflag %2d\n",iflag);
Double_t nll = 0;
Double_t eSigma;
//printf("par[0] = %5f\n",par[0]);
for (Int_t i=0; i<nEvts; i++){
//Calculate the actual sigma value in this event
eSigma = TMath::Sqrt((tSigma**2)+((nSigma*rTime[i]))**2);
Double_t ll1 = mixing(lifetime[i],tau,dm_fit,eSigma,1);
Double_t ll2 = mixing(lifetime[i],tau,dm_fit,eSigma,-1);
if (tag[i] == -1){
Double_t ll = (1-par[0])*ll1 + par[0]*ll2;
}
if (tag[i] == 1){
Double_t ll = (1-par[0])*ll2 + par[0]*ll1;
}
if ( i == nEvts/4 ){
//printf("rTime = %4f, lifetime= %4f, eSigma = %4f\n",rTime[i],lifetime[i],eSigma);
//printf("ll = %12f, ll1 = %12f, ll2 = %12f, \n",ll, ll1, ll2);
}
nll -= TMath::Log(ll);
}
f = nll;
//printf("f = %10f\n",f);
}
int main()
{
int n;
printf("Input size of field: ");
scanf("%d", &n);
int field[n][n];
mixing(n, field);
total(n, field);
initscr();
curs_set(0);
start_color();
init_pair(1, COLOR_BLACK, COLOR_YELLOW);
attron(COLOR_PAIR(1));
output_field(n, field, 0);
contin(n, field);
attroff(COLOR_PAIR(1));
refresh();
endwin();
return 0;
}
void errf_test_jh(){
//---- Loop over tSigma values
for (Int_t ts=0; ts<tsmax; ts++){
tSigma = 1 - (ts/10.);
//tSigma = 0.1;
//---- Make a table header for the list of values
printf("\n=======================[tSigma=%3.1f]============================\n",tSigma);
printf(" lt | umfunc_val old_umfunc_val | mfunc_val old_mfunc_val\n");
printf(" ------------------------------------------------------------\n");
//---- Loop over possible lifetime values
for (Int_t jg=-4.; jg<20.; jg++){
Float_t jt = jg/2.;
//---- Run the functions
Double_t umfunc_val = 2.*mixing(jt, tau, dm, tSigma,-1);
Double_t mfunc_val = 2.*mixing(jt, tau, dm, tSigma,1);
//---- Run the old functions to compare
Double_t old_umfunc_val = 2.*old_uNmix(jt, tau, dm, tSigma);
Double_t old_mfunc_val = 2.*old_mix(jt, tau, dm, tSigma);
//---- Output to the table the lifetime value and function result
printf(" %4.1f | %8.6lf %8.6lf | %8.6lf %8.6lf\n",jt,umfunc_val,old_umfunc_val,mfunc_val,old_mfunc_val);
}
printf(" --------------------------------------------------------------\n");
}
gROOT->SetStyle("Plain");
//-----------------------------------------------------------
tSigma=0.2;
TF1 *funmix = new TF1("funmix", lftmosc_plt,-4,15,4);
funmix->SetParameters(1.5,0.51,tSigma,-1);
TF1 *fmix = new TF1("fmix", lftmosc_plt,-4,15,4);
fmix->SetParameters(1.5,0.51,tSigma,1);
TF1 *fold_unmix = new TF1("fold_unmix", old_lftmosc_plt,-4,7.5,4);
fold_unmix->SetParameters(1.5,0.51,tSigma,-1);
fold_unmix->SetLineColor(2);
fold_unmix->SetLineWidth(10);
fold_unmix->SetLineStyle(3);
fold_unmix->SetTitle("tSigma = 0.2");
TF1 *fold_mix = new TF1("fold_mix", old_lftmosc_plt,-4,7.5,4);
fold_mix->SetParameters(1.5,0.51,tSigma,1);
fold_mix->SetLineColor(2);
fold_mix->SetLineWidth(10);
fold_mix->SetLineStyle(3);
//-----------------------------------------------------------
tSigma=0.4;
TF1 *funmix2 = new TF1("funmix2", lftmosc_plt,-4,15,4);
funmix2->SetParameters(1.5,0.51,tSigma,-1);
TF1 *fmix2 = new TF1("fmix2", lftmosc_plt,-4,15,4);
fmix2->SetParameters(1.5,0.51,tSigma,1);
TF1 *fold_unmix2 = new TF1("fold_unmix2", old_lftmosc_plt,-4,15,4);
fold_unmix2->SetParameters(1.5,0.51,tSigma,-1);
fold_unmix2->SetLineColor(2);
fold_unmix2->SetTitle("tSigma = 0.4");
fold_unmix2->SetLineStyle(3);
fold_unmix2->SetLineWidth(10);
TF1 *fold_mix2= new TF1("fold_mix2", old_lftmosc_plt,-4,15,4);
fold_mix2->SetParameters(1.5,0.51,tSigma,1);
fold_mix2->SetLineColor(2);
fold_mix2->SetLineStyle(3);
fold_mix2->SetLineWidth(10);
//---------------------------------------------------------
tSigma=0.6;
TF1 *funmix3 = new TF1("funmix3", lftmosc_plt,-4,15,4);
funmix3->SetParameters(1.5,0.51,tSigma,-1);
TF1 *fmix3 = new TF1("fmix3", lftmosc_plt,-4,15,4);
fmix3->SetParameters(1.5,0.51,tSigma,1);
TF1 *fold_unmix3 = new TF1("fold_unmix3", old_lftmosc_plt,-4,15,4);
fold_unmix3->SetParameters(1.5,0.51,tSigma,-1);
fold_unmix3->SetLineColor(2);
fold_unmix3->SetTitle("tSigma = 0.6");
fold_unmix3->SetLineStyle(3);
fold_unmix3->SetLineWidth(10);
TF1 *fold_mix3 = new TF1("fold_mix3", old_lftmosc_plt,-4,15,4);
fold_mix3->SetParameters(1.5,0.51,tSigma,1);
fold_mix3->SetLineColor(2);
fold_mix3->SetLineWidth(10);
fold_mix3->SetLineStyle(3);
//--------------------------------------------------------
tSigma=0.8;
TF1 *funmix4 = new TF1("funmix4", lftmosc_plt,-4,15,4);
funmix4->SetParameters(1.5,0.51,tSigma,-1);
TF1 *fmix4 = new TF1("fmix4", lftmosc_plt,-4,15,4);
fmix4->SetParameters(1.5,0.51,tSigma,1);
TF1 *fold_unmix4 = new TF1("fold_unmix4", old_lftmosc_plt,-4,15,4);
fold_unmix4->SetParameters(1.5,0.51,tSigma,-1);
fold_unmix4->SetLineColor(2);
fold_unmix4->SetTitle("tSigma = 0.8");
fold_unmix4->SetLineStyle(3);
fold_unmix4->SetLineWidth(10);
TF1 *fold_mix4= new TF1("fold_mix4", old_lftmosc_plt,-4,15,4);
fold_mix4->SetParameters(1.5,0.51,tSigma,1);
fold_mix4->SetLineColor(2);
fold_mix4->SetLineStyle(3);
fold_mix4->SetLineWidth(10);
//--------------------------------------------------------
TCanvas *c2 = new TCanvas("c2","c2",1200,1000);
c2->Divide(2,2);
c2->cd(1);
fold_unmix->Draw();
fold_mix->Draw("SAME");
funmix->Draw("SAME");
fmix->Draw("SAME");
c2->cd(2);
fold_unmix2->Draw();
fold_mix2->Draw("SAME");
funmix2->Draw("SAME");
fmix2->Draw("SAME");
c2->cd(3);
fold_unmix3->Draw();
fold_mix3->Draw("SAME");
funmix3->Draw("SAME");
fmix3->Draw("SAME");
c2->cd(4);
fold_unmix4->Draw();
fold_mix4->Draw("SAME");
funmix4->Draw("SAME");
fmix4->Draw("SAME");
}
OptionalModelObject ReverseTranslator::translateZoneMixing( const WorkspaceObject & workspaceObject )
{
if( workspaceObject.iddObject().type() != IddObjectType::ZoneMixing ){
LOG(Error, "WorkspaceObject is not IddObjectType: ZoneMixing");
return boost::none;
}
OptionalWorkspaceObject target = workspaceObject.getTarget(openstudio::ZoneMixingFields::ZoneName);
OptionalThermalZone zone;
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
zone = modelObject->optionalCast<ThermalZone>();
}
}
if (!zone){
return boost::none;
}
openstudio::model::ZoneMixing mixing(*zone);
OptionalString s = workspaceObject.name();
if(s){
mixing.setName(*s);
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::ScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setSchedule(s.get());
}
}
}
s = workspaceObject.getString(openstudio::ZoneMixingFields::DesignFlowRateCalculationMethod, true);
OS_ASSERT(s);
OptionalDouble d;
if (istringEqual("Flow/Zone", *s)){
d = workspaceObject.getDouble(openstudio::ZoneMixingFields::DesignFlowRate);
if (d){
mixing.setDesignFlowRate(*d);
} else{
LOG(Error, "Flow/Zone value not found for workspace object " << workspaceObject);
}
} else if (istringEqual("Flow/Area", *s)){
d = workspaceObject.getDouble(openstudio::ZoneMixingFields::FlowRateperZoneFloorArea);
if (d){
mixing.setFlowRateperZoneFloorArea(*d);
} else{
LOG(Error, "Flow/Area value not found for workspace object " << workspaceObject);
}
} else if (istringEqual("Flow/Person", *s)){
d = workspaceObject.getDouble(openstudio::ZoneMixingFields::FlowRateperPerson);
if (d){
mixing.setFlowRateperPerson(*d);
} else{
LOG(Error, "Flow/Person value not found for workspace object " << workspaceObject);
}
} else if (istringEqual("AirChanges/Hour", *s)){
d = workspaceObject.getDouble(openstudio::ZoneMixingFields::AirChangesperHour);
if (d){
mixing.setAirChangesperHour(*d);
} else{
LOG(Error, "AirChanges/Hour value not found for workspace object " << workspaceObject);
}
} else{
LOG(Error, "Unknown DesignFlowRateCalculationMethod value for workspace object" << workspaceObject);
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::SourceZoneName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (modelObject->optionalCast<ThermalZone>()){
mixing.setSourceZone(modelObject->cast<ThermalZone>());
}
}
}
d = workspaceObject.getDouble(openstudio::ZoneMixingFields::DeltaTemperature);
if (d){
mixing.setDeltaTemperature(*d);
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::DeltaTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setDeltaTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MinimumZoneTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMinimumZoneTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MaximumZoneTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMaximumZoneTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MinimumSourceZoneTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMinimumSourceZoneTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MaximumSourceZoneTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMaximumSourceZoneTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MinimumOutdoorTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMinimumOutdoorTemperatureSchedule(s.get());
}
}
}
target = workspaceObject.getTarget(openstudio::ZoneMixingFields::MaximumOutdoorTemperatureScheduleName);
if (target){
OptionalModelObject modelObject = translateAndMapWorkspaceObject(*target);
if (modelObject){
if (auto s = modelObject->optionalCast<Schedule>()){
mixing.setMaximumOutdoorTemperatureSchedule(s.get());
}
}
}
return mixing;
}
